Collections 工具类

针对 List 集合的方法

排序 sort

如果集合元素为基本数据类型，采用快排；对于集合元素为引用类型，采用归并排序。

//对指定 List 集合的元素按照自然排序
void sort(List<?> list);

//对 List 集合元素根据 Comparator 进行排序
void sort(List<T> list, Comparator<? super T> c);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
    System.out.println(nums);  //[10, -5, 20, 0]

    //自然排序
    Collections.sort(nums);
    System.out.println(nums);  //[-5, 0, 10, 20]

    //自定义排序，降序排列
    Collections.sort(nums, (o1, o2) -> o1 < o2 ? 1 : (o1 == o2 ? 0 : -1));
    System.out.println(nums);  //[20, 10, 0, -5]
}

二分查找 binarySearch

//List 必须是有序的，且按照自然顺序排序
int binarySearch(List<? extends Comparable<? super T>> list, T key);

//List 必须有序，且根据 Comparator 排序
int binarySearch(List<? extends T> list, T key, Comparator<? super T> c);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());

    //自然排序
    Collections.sort(nums);
    System.out.println(nums);  //[-5, 0, 10, 20]
    //找到元素，直接返回索引
    System.out.println(Collections.binarySearch(nums, 10));  //2
    //未找到元素，返回 -(最后一次查找位置 + 1)
    //最后一次查找位置是元素 10 位置（就是插入位置），索引为 2 ，所以返回 -3
    System.out.println(Collections.binarySearch(nums, 1));  //-3

    //自定义排序，降序排列
    Comparator<Integer> c = (o1, o2) -> o1 < o2 ? 1 : (o1 == o2 ? 0 : -1);
    Collections.sort(nums, c);
    System.out.println(nums);    //[20, 10, 0, -5]
    System.out.println(Collections.binarySearch(nums, 10, c));  //1
    System.out.println(Collections.binarySearch(nums, 1, c));   //-3
}

反转 reverse

//将 list 集合中元素反转
void reverse(List<?> list);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
    System.out.println(nums);  //[10, -5, 20, 0]

    //列表反转
    Collections.reverse(nums);
    System.out.println(nums);  //[0, 20, -5, 10]
}

打乱顺序 shuffle

//按照系统自动生成的随机数对 List 顺序打乱（洗牌操作）
void shuffle(List<?> list);

//按照指定的随机数将 List 顺序打乱
void shuffle(List<?> list, Random rnd);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
    System.out.println(nums);  //[10, -5, 20, 0]

    Collections.shuffle(nums);
    System.out.println(nums);  //[10, 0, 20, -5]

    Collections.shuffle(nums, new Random());
    System.out.println(nums);  //[0, -5, 10, 20]
}

交换顺序 swap

//将指定 List 集合中的 i 处元素和 j 处元素进行交换
void swap(List<?> list, int i, int j);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
    System.out.println(nums);  //[10, -5, 20, 0]

    //交换索引 1 和 2 位置的元素
    Collections.swap(nums, 1, 2);
    System.out.println(nums);  //[10, 20, -5, 0]
}

移位 rotate

//当 distance 为正数时，循环右移
//当 distance 为负数时，循环左移
void rotate(List<?> list, int distance);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
    System.out.println(nums);  //[10, -5, 20, 0]

    //循环右移
    Collections.rotate(nums, 1);
    System.out.println(nums);  //[0, 10, -5, 20]

    //循环左移
    Collections.rotate(nums, -1);
    System.out.println(nums);  //[10, -5, 20, 0]
}

填充 fill

//将 list 中的全部元素填充为 obj
void fill(List<? super T> list, T obj);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
    System.out.println(nums);  //[10, -5, 20, 0]

    Collections.fill(nums, -1);
    System.out.println(nums);  //[-1, -1, -1, -1]
}

查找子集位置 indexOfSubList/lastIndexOfSubList

//返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
int indexOfSubList(List<?> source, List<?> target);

//返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
int lastIndexOfSubList(List<?> source, List<?> target);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(1,2,2,3,3).stream().collect(Collectors.toList());
    System.out.println(nums);      //[1, 2, 2, 3, 3]

    List subList = Arrays.asList(2);
    System.out.println(Collections.indexOfSubList(nums, subList)); //1
    System.out.println(Collections.lastIndexOfSubList(nums, subList)); //2
}

替换 replaceAll

//使用一个新值替换 List 对象的所有旧值 oldVal。
boolean replaceAll(List<T> list, T oldVal, T newVal);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(1,2,2,3,3).stream().collect(Collectors.toList());
    System.out.println(nums);      //[1, 2, 2, 3, 3]

    Collections.replaceAll(nums, 2 ,4);
    System.out.println(nums);      //[1, 4, 4, 3, 3]
}

针对 Collection 集合的方法

求极值 min/max

//自然排序中的最小值和最大值
T min(Collection<? extends T> coll);
T max(Collection<? extends T> coll);

//自定义排序中的最小值和最大值
T min(Collection<? extends T> coll, Comparator<? super T> comp);
T max(Collection<? extends T> coll, Comparator<? super T> comp);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());

    System.out.println(Collections.max(nums));  //20
    System.out.println(Collections.min(nums));  //-5

    //自定义大小
    Comparator<Integer> c = (o1, o2) -> o1 < o2 ? 1 : (o1 == o2 ? 0 : -1);
    System.out.println(Collections.max(nums, c)); //-5
    System.out.println(Collections.min(nums, c)); //20
}

求频率 frequency

//返回指定 collection 中等于指定对象的出现次数。
int frequency(Collection<?> c, Object o);

public static void main(String[] args) {
    List<Integer> nums = Arrays.asList(10,-5,-5,0).stream().collect(Collectors.toList());
    System.out.println(Collections.frequency(nums, -5));  //2
}

线程同步控制

HashSet，TreeSet，arrayList，LinkedList，HashMap，TreeMap 等集合都是线程不安全的。如果有多个线程访问它们，而且有超过一个的线程试图修改它们，则存在线程安全的问题。Collections 提供了多个静态方法可以把他们包装成线程同步的集合。

//返回指定 collection 支持的同步（线程安全的）collection。
Collection<T> synchronizedCollection(Collection<T> c);

//返回指定列表支持的同步（线程安全的）列表。
List<T> synchronizedList(List<T> list);

//返回由指定映射支持的同步（线程安全的）映射。
Map<K,V> synchronizedMap(Map<K,V> m);

//返回指定 set 支持的同步（线程安全的）set。 
Set<T> synchronizedSet(Set<T> s);

public static void main(String[] args) {
    //直接将新创建的集合对象传给synchronizedXxx方法
    //下面程序创建了4个线程安全的集合对象
    Collection c = Collections.synchronizedCollection(new ArrayList());
    List list = Collections.synchronizedList(new ArrayList());
    Set s = Collections.synchronizedSet(new HashSet());
    Map m = Collections.synchronizedMap(new HashMap());
}

设置不可变集合

Collections 提供了上述三种方法来返回一个不可变的集合。上述三类方法的参数是原有的集合对象，返回值是该集合的 "只读" 版本。

//返回一个空的、不可变的集合对象。
Set<T> emptySet()
List<T> emptyList();
Map<K,V> emptyMap();

//返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，
Set<T> singleton(T o)
List<T> singletonList(T o);
Map<K,V> singletonMap(K key, V value);

//返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。
Set<T> unmodifiableSet(Set<? extends T> s);
List<T> unmodifiableList(List<? extends T> list);
Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m);

public static void main(String[] args) {
    //创建一个空的、不可改变的List对象
    List<String> unmodifiableList = Collections.emptyList();
    
    //创建一个只有一个元素，且不可改变的Set对象
    Set unmodifiableSet = Collections.singleton("疯狂Java讲义");
    
    //创建一个普通的Map对象
    Map scores = new HashMap();
    scores.put("语文" , 80);
    scores.put("Java" , 82);
    //返回普通Map对象对应的不可变版本
    Map unmodifiableMap = Collections.unmodifiableMap(scores);
    
    //下面任意一行代码都将引发UnsupportedOperationException异常
    unmodifiableList.add("测试元素");
    unmodifiableSet.add("测试元素");
    unmodifiableMap.put("语文",90);
}