java如何使用Collections工具类操作集合 javaCollections工具类应用的实用教程​

collections工具类提供了多种静态方法简化集合操作，1. sort()对list排序，底层根据list类型和大小选择插入排序或timsort；2. binarysearch()在已排序list中查找元素；3. reverse()反转list元素顺序；4. fill()将list所有元素替换为指定值；5. copy()将源list复制到目标list；6. max()/min()查找集合最大值和最小值；7. replaceall()替换list中所有旧值为新值；此外还提供shuffle()打乱顺序、frequency()统计频次、rotate()循环移动、ncopies()创建重复元素列表、singleton系列创建单元素不可变集合、empty系列返回空不可变集合、unmodifiable系列创建只读集合，以及synchronized系列将集合转换为线程安全集合，但迭代时仍需手动加锁以保证复合操作的线程安全，这些方法共同提升了集合操作的效率和代码安全性。

java中，Collections工具类提供了一系列静态方法，用于操作集合，例如排序、查找、替换等，极大地简化了集合操作的代码。它不是集合类，而是一个工具类，包含处理集合的各种方法。

解决方案 Collections工具类提供了许多实用方法，下面是一些常见用法：

1. 排序 (sort)

Collections.sort() 方法可以对List集合进行排序。默认情况下，它使用自然排序（升序）。如果需要自定义排序规则，可以使用Comparator接口。

立即学习“Java免费学习笔记（深入）”；

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortExample {
    public static void main(String[] args) {
        List numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);

        Collections.sort(numbers); // 默认升序排序
        System.out.println("升序排序: " + numbers); // 输出: 升序排序: [1, 2, 5, 8]

        // 自定义排序 (降序)
        Collections.sort(numbers, (a, b) -> b.compareTo(a));
        System.out.println("降序排序: " + numbers); // 输出: 降序排序: [8, 5, 2, 1]
    }
}

2. 查找 (binarySearch)

binarySearch() 方法用于在已排序的List集合中查找指定元素。 需要注意的是，集合必须先排序，否则结果不确定。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class BinarySearchExample {
    public static void main(String[] args) {
        List names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");

        Collections.sort(names); // 先排序

        int index = Collections.binarySearch(names, "Bob");
        System.out.println("Bob 的索引: " + index); // 输出: Bob 的索引: 1

        int notFound = Collections.binarySearch(names, "Eve");
        System.out.println("Eve 的索引: " + notFound); // 输出: Eve 的索引: -5  (表示不存在)
    }
}

3. 反转 (reverse)

reverse() 方法用于反转List集合中元素的顺序。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ReverseExample {
    public static void main(String[] args) {
        List letters = new ArrayList<>();
        letters.add("A");
        letters.add("B");
        letters.add("C");

        Collections.reverse(letters);
        System.out.println("反转后的集合: " + letters); // 输出: 反转后的集合: [C, B, A]
    }
}

4. 填充 (fill)

fill() 方法用于将List集合中的所有元素替换为指定的值。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class FillExample {
    public static void main(String[] args) {
        List numbers = new ArrayList<>();
        numbers.add(1);
        numbers.add(2);
        numbers.add(3);

        Collections.fill(numbers, 0);
        System.out.println("填充后的集合: " + numbers); // 输出: 填充后的集合: [0, 0, 0]
    }
}

5. 复制 (copy)

copy() 方法用于将一个List集合的元素复制到另一个List集合中。目标集合的大小必须大于或等于源集合的大小。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CopyExample {
    public static void main(String[] args) {
        List source = new ArrayList<>();
        source.add(1);
        source.add(2);
        source.add(3);

        List destination = new ArrayList<>();
        destination.add(4);
        destination.add(5);
        destination.add(6);
        destination.add(7); // 目标集合大小 >= 源集合大小

        Collections.copy(destination, source);
        System.out.println("复制后的目标集合: " + destination); // 输出: 复制后的目标集合: [1, 2, 3, 7]
    }
}

6. 查找最大/最小值 (max/min)

max() 和 min() 方法用于查找集合中的最大值和最小值。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class MaxMinExample {
    public static void main(String[] args) {
        List values = new ArrayList<>();
        values.add(3.14);
        values.add(1.618);
        values.add(2.718);

        Double max = Collections.max(values);
        Double min = Collections.min(values);

        System.out.println("最大值: " + max); // 输出: 最大值: 3.14
        System.out.println("最小值: " + min); // 输出: 最小值: 1.618
    }
}

7. 替换 (replaceAll)

replaceAll() 方法用于将List集合中所有指定的旧值替换为新值。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ReplaceAllExample {
    public static void main(String[] args) {
        List colors = new ArrayList<>();
        colors.add("Red");
        colors.add("Blue");
        colors.add("Red");

        Collections.replaceAll(colors, "Red", "Green");
        System.out.println("替换后的集合: " + colors); // 输出: 替换后的集合: [Green, Blue, Green]
    }
}

Collections工具类还提供了许多其他有用的方法，例如：

• shuffle()

  : 随机打乱集合元素的顺序。

• frequency()

  : 计算集合中指定元素出现的次数。

• synchronizedList()

  ,

  synchronizedSet()

  ,

  synchronizedMap()

  : 将非线程安全的集合转换为线程安全的集合。

• unmodifiableList()

  ,

  unmodifiableSet()

  ,

  unmodifiableMap()

  : 创建只读的集合。

使用Collections工具类可以大大简化集合操作，提高代码的可读性和效率。

Collections.sort()方法内部是如何实现排序的？

Collections.sort() 方法在底层使用了不同的排序算法，具体取决于List集合的类型和大小。

• 对于实现了

  RandomAccess

  接口的 List (如

  ArrayList

  ) 且元素数量较少时，使用插入排序 (Insertion Sort)。 插入排序对于小规模数据或基本有序的数据效率很高。
• 对于实现了

  RandomAccess

  接口的 List 且元素数量较多时，使用归并排序 (Merge Sort) 的变种，称为 Timsort。 Timsort 是一种混合排序算法，结合了插入排序和归并排序的优点，能够高效地处理各种类型的输入数据。
• 对于没有实现

  RandomAccess

  接口的 List (如

  LinkedList

  )，会将 List 转换为数组，然后使用 Timsort 排序，最后再将排序后的数组转换回 List。

Timsort 的主要思想是：

1. 将数组分成多个小的 "run"，每个 run 都是有序的。 run 的长度通常在 32 到 64 之间。
2. 如果 run 的长度小于最小长度，则使用插入排序扩展 run。
3. 将相邻的 run 合并成更大的有序 run，直到整个数组有序。 合并过程中会使用归并排序的思想。

Timsort 的优点在于：

• 能够高效地处理部分有序的数据。
• 具有较好的平均性能和最坏情况性能。
• 是稳定的排序算法，即相等元素的相对顺序不会改变。

总而言之，Collections.sort() 方法会根据 List 的类型和大小选择合适的排序算法，以达到最佳的排序性能。

如何使用Collections创建线程安全的集合？

Collections类提供了一系列的静态方法，可以将普通的集合转换为线程安全的集合，主要有以下几种：

• synchronizedCollection(Collection c)

  : 返回指定 collection 支持的同步（线程安全的）collection。

• synchronizedList(List list)

  : 返回指定列表支持的同步（线程安全的）列表。

• synchronizedSet(Set s)

  : 返回指定 set 支持的同步（线程安全的）set。

• synchronizedMap(Map m)

  : 返回指定 map 支持的同步（线程安全的）map。

• synchronizedSortedSet(SortedSet s)

  : 返回指定有序 set 支持的同步（线程安全的）有序 set。

• synchronizedSortedMap(SortedMap m)

  : 返回指定有序 map 支持的同步（线程安全的）有序 map。

使用方法很简单，只需要将需要同步的集合作为参数传递给相应的方法即可。

ShopEx助理

一个类似淘宝助理、ebay助理的客户端程序，用来方便的在本地处理商店数据，并能够在本地商店、网上商店和第三方平台之间实现数据上传下载功能的工具。功能说明如下：1.连接本地商店：您可以使用ShopEx助理连接一个本地安装的商店系统，这样就可以使用助理对本地商店的商品数据进行编辑等操作，并且数据也将存放在本地商店数据库中。默认是选择“本地未安装商店”，本地还未安

下载

import java.util.*;

public class SynchronizedCollectionExample {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        Set set = new HashSet<>();
        Map map = new HashMap<>();

        // 创建线程安全的集合
        List synchronizedList = Collections.synchronizedList(list);
        Set synchronizedSet = Collections.synchronizedSet(set);
        Map synchronizedMap = Collections.synchronizedMap(map);

        // 现在可以安全地在多线程环境中使用这些集合
        // ...
    }
}

需要注意的是：

• 这些方法返回的集合实际上是对原始集合的包装，所有对集合的访问都必须通过这个包装器进行。
• 虽然这些集合是线程安全的，但仍然需要注意复合操作的线程安全性。 例如，迭代集合时仍然需要手动加锁，以避免并发修改异常。

示例：迭代线程安全的List

import java.util.*;

public class SynchronizedListIterationExample {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("A");
        list.add("B");
        list.add("C");

        List synchronizedList = Collections.synchronizedList(list);

        synchronized (synchronizedList) { // 手动加锁
            Iterator iterator = synchronizedList.iterator();
            while (iterator.hasNext()) {
                String element = iterator.next();
                System.out.println(element);
            }
        }
    }
}

为什么需要手动加锁来迭代线程安全的集合？

即使使用了

Collections.synchronizedList()

• Collections.synchronizedList()

  只是保证了每个单独的操作（如

  add()

  ,

  remove()

  ,

  get()

  ,

  set()

  等）是原子性的，即在执行这些操作时，不会有其他线程干扰。
• 但是，迭代集合通常需要执行多个操作，例如

  hasNext()

  和

  next()

  ，这些操作组合在一起就不是原子性的了。 如果在迭代过程中，另一个线程修改了集合，就可能导致

  ConcurrentModificationException

  异常或产生不可预测的结果。

举个例子：

假设有两个线程同时迭代同一个

synchronizedList

1. 线程 A 调用

   iterator.hasNext()

   ，返回

   true

   。
2. 在线程 A 调用

   iterator.next()

   之前，线程 B 从集合中删除了一个元素。
3. 线程 A 调用

   iterator.next()

   ，此时集合的结构已经发生了变化，

   next()

   方法可能会抛出

   ConcurrentModificationException

   异常，或者返回错误的结果。

为了避免这种情况，需要在迭代集合时手动加锁，确保在迭代过程中没有其他线程修改集合。

synchronized (synchronizedList)

synchronizedList

总结：

• Collections.synchronizedList()

  等方法提供了基本的线程安全性，保证了单个操作的原子性。
• 对于需要多个操作组合在一起的场景（如迭代），仍然需要手动加锁来保证线程安全性。
• 手动加锁是确保多线程环境下集合操作正确性的重要手段。

Collections工具类还有哪些其他的实用方法？

除了前面提到的排序、查找、反转、填充、复制、最大/最小值、替换以及创建线程安全集合之外，Collections 工具类还提供了许多其他实用的方法，可以极大地简化集合操作：

1. shuffle(List> list): 随机打乱集合元素的顺序

这个方法可以用于洗牌、抽奖等需要随机性的场景。

import java.util.*;

public class ShuffleExample {
    public static void main(String[] args) {
        List numbers = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            numbers.add(i);
        }

        Collections.shuffle(numbers);
        System.out.println("打乱后的集合: " + numbers);
    }
}

2. frequency(Collection> c, Object o): 计算集合中指定元素出现的次数

这个方法可以用于统计某个元素在集合中出现的频率。

import java.util.*;

public class FrequencyExample {
    public static void main(String[] args) {
        List names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Alice");
        names.add("Charlie");
        names.add("Alice");

        int frequency = Collections.frequency(names, "Alice");
        System.out.println("Alice 出现的次数: " + frequency); // 输出: Alice 出现的次数: 3
    }
}

3. rotate(List> list, int distance): 将集合中的元素循环移动指定的距离

如果 distance 为正数，则将元素向右移动；如果 distance 为负数，则将元素向左移动。

import java.util.*;

public class RotateExample {
    public static void main(String[] args) {
        List letters = new ArrayList<>();
        letters.add("A");
        letters.add("B");
        letters.add("C");
        letters.add("D");

        Collections.rotate(letters, 2); // 向右移动 2 个位置
        System.out.println("旋转后的集合: " + letters); // 输出: 旋转后的集合: [C, D, A, B]
    }
}

4. nCopies(int n, Object o): 创建一个包含 n 个指定对象的不可变列表

这个方法可以用于快速创建包含重复元素的列表。

import java.util.*;

public class NCopiesExample {
    public static void main(String[] args) {
        List repeatedStrings = Collections.nCopies(5, "Hello");
        System.out.println("重复的字符串列表: " + repeatedStrings); // 输出: 重复的字符串列表: [Hello, Hello, Hello, Hello, Hello]
    }
}

5. singleton(Object o), singletonList(Object o), singletonMap(K key, V value): 创建只包含一个元素的不可变集合

这些方法可以用于创建只包含一个元素的集合，例如在需要返回单个元素的集合时。

import java.util.*;

public class SingletonExample {
    public static void main(String[] args) {
        Set singleStringSet = Collections.singleton("World");
        System.out.println("单元素集合: " + singleStringSet); // 输出: 单元素集合: [World]

        List singleIntegerList = Collections.singletonList(123);
        System.out.println("单元素列表: " + singleIntegerList); // 输出: 单元素列表: [123]

        Map singleMap = Collections.singletonMap("Age", 30);
        System.out.println("单元素 Map: " + singleMap); // 输出: 单元素 Map: {Age=30}
    }
}

6. emptyList(), emptySet(), emptyMap(): 返回一个空的不可变集合

这些方法可以用于避免返回 null，提高代码的健壮性。

import java.util.*;

public class EmptyCollectionExample {
    public static void main(String[] args) {
        List emptyList = Collections.emptyList();
        System.out.println("空列表: " + emptyList); // 输出: 空列表: []

        Set emptySet = Collections.emptySet();
        System.out.println("空 Set: " + emptySet); // 输出: 空 Set: []

        Map emptyMap = Collections.emptyMap();
        System.out.println("空 Map: " + emptyMap); // 输出: 空 Map: {}
    }
}

7. unmodifiableCollection(Collection extends T> c), unmodifiableList(List extends T> list), unmodifiableSet(Set extends T> s), unmodifiableMap(Map extends K, ? extends V> m): 创建只读的集合

这些方法可以防止集合被修改，提高代码的安全性。任何尝试修改这些只读集合的操作都会抛出

UnsupportedOperationException

import java.util.*;

public class UnmodifiableCollectionExample {
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("A");
        list.add("B");

        List unmodifiableList = Collections.unmodifiableList(list);

        try {
            unmodifiableList.add("C"); // 尝试修改只读列表，会抛出异常
        } catch (UnsupportedOperationException e) {
            System.out.println("无法修改只读列表");
        }
    }
}

总而言之，Collections 工具类提供了非常丰富的静态方法，可以方便地进行各种集合操作，提高代码的效率和可读性。熟练掌握这些方法，可以让你在 Java 集合操作中更加得心应手。