说一说 Collections 工具类的用法总结

1、排序操作

• reverse(List list)：反转顺序
• shuffle(List list)：洗牌，将顺序打乱
• sort(List list)：自然升序
• sort(List list, Comparator c)：按照自定义的比较器排序
• swap(List list, int i, int j)：将 i 和 j 位置的元素交换位置

来看例子：

1. List<String> list = new ArrayList<>();
2. list.add("二");
3. list.add("三");
4. list.add("四");
5. list.add("五");
6. list.add("六");
8. System.out.println("原始顺序：" + list);
10. // 反转
11. Collections.reverse(list);
12. System.out.println("反转后：" + list);
14. // 洗牌
15. Collections.shuffle(list);
16. System.out.println("洗牌后：" + list);
18. // 自然升序
19. Collections.sort(list);
20. System.out.println("自然升序后：" + list);
22. // 交换
23. Collections.swap(list, 2,4);
24. System.out.println("交换后：" + list);

输出后：

1. 原始顺序：[二, 三, 四, 五, 六]
2. 反转后：[六, 五, 四, 三, 二]
3. 洗牌后：[五, 二, 六, 三, 四]
4. 自然升序后：[三, 二, 五, 六, 四]
5. 交换后：[三, 二, 四, 六, 五]

2、查找操作

• binarySearch(List list, Object key)：二分查找法，前提是 List 已经排序过了
• max(Collection coll)：返回最大元素
• max(Collection coll, Comparator comp)：根据自定义比较器，返回最大元素
• min(Collection coll)：返回最小元素
• min(Collection coll, Comparator comp)：根据自定义比较器，返回最小元素
• fill(List list, Object obj)：使用指定对象填充
• frequency(Collection c, Object o)：返回指定对象出现的次数

来看例子：

1. System.out.println("最大元素：" + Collections.max(list));
2. System.out.println("最小元素：" + Collections.min(list));
3. System.out.println("出现的次数：" + Collections.frequency(list, "二"));
5. // 没有排序直接调用二分查找，结果是不确定的
6. System.out.println("排序前的二分查找结果：" + Collections.binarySearch(list, "二"));
7. Collections.sort(list);
8. // 排序后，查找结果和预期一致
9. System.out.println("排序后的二分查找结果：" + Collections.binarySearch(list, "二"));
11. Collections.fill(list, "八");
12. System.out.println("填充后的结果：" + list);

输出后：

1. 原始顺序：[二, 三, 四, 五, 六]
2. 最大元素：四
3. 最小元素：三
4. 出现的次数：1
5. 排序前的二分查找结果：0
6. 排序后的二分查找结果：1
7. 填充后的结果：[八, 八, 八, 八, 八]

3、同步控制

HashMap 是线程不安全的，其实 ArrayList 也是线程不安全的，没法在多线程环境下使用，那 Collections 工具类中提供了多个 synchronizedXxx 方法，这些方法会返回一个同步的对象，从而解决多线程中访问集合时的安全问题。

使用起来也非常的简单：

1. SynchronizedList synchronizedList = Collections.synchronizedList(list);

看一眼 SynchronizedList 的源码就明白了，不过是在方法里面使用 synchronized 关键字加了一层锁而已。

1. static class SynchronizedList<E>
2.    extends SynchronizedCollection<E>
3.    implements List<E> {
4.    private static final long serialVersionUID = -7754090372962971524L;
6.    final List<E> list;
8.    SynchronizedList(List<E> list) {
9.        super(list);
10.        this.list = list;
11.    }
13.    public E get(int index) {
14.        synchronized (mutex) {return list.get(index);}
15.    }
17.    public void add(int index, E element) {
18.        synchronized (mutex) {list.add(index, element);}
19.    }
20.    public E remove(int index) {
21.        synchronized (mutex) {return list.remove(index);}
22.    }
23. }

那这样的话，其实效率和那些直接在方法上加 synchronized 关键字的 Vector、Hashtable 差不多（JDK 1.0 时期就有了），而这些集合类基本上已经废弃了，几乎不怎么用。

1. public class Vector<E>
2.    extends AbstractList<E>
3.    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
4. {
6.    public synchronized E get(int index) {
7.        if (index >= elementCount)
8.            throw new ArrayIndexOutOfBoundsException(index);
10.        return elementData(index);
11.    }
13.    public synchronized E remove(int index) {
14.        modCount++;
15.        if (index >= elementCount)
16.            throw new ArrayIndexOutOfBoundsException(index);
17.        E oldValue = elementData(index);
19.        int numMoved = elementCount - index - 1;
20.        if (numMoved > 0)
21.            System.arraycopy(elementData, index+1, elementData, index,
22.                             numMoved);
23.        elementData[--elementCount] = null; // Let gc do its work
25.        return oldValue;
26.    }
27. }

正确的做法是使用并发包下的 CopyOnWriteArrayList、ConcurrentHashMap。这些放到并发编程时再讲。

4、不可变集合

• emptyXxx()：制造一个空的不可变集合
• singletonXxx()：制造一个只有一个元素的不可变集合
• unmodifiableXxx()：为指定集合制作一个不可变集合

举个例子：

1. List emptyList = Collections.emptyList();
2. emptyList.add("非空");
3. System.out.println(emptyList);

这段代码在执行的时候就抛出错误了。

1. Exception in thread "main" java.lang.UnsupportedOperationException
2. at java.util.AbstractList.add(AbstractList.java:148)
3. at java.util.AbstractList.add(AbstractList.java:108)
4. at com.itwanger.s64.Demo.main(Demo.java:61)

这是因为 Collections.emptyList() 会返回一个 Collections 的内部类 EmptyList，而 EmptyList 并没有重写父类 AbstractList 的 add(int index, E element) 方法，所以执行的时候就抛出了不支持该操作的 UnsupportedOperationException 了。

这是从分析 add 方法源码得出的原因。除此之外，emptyList 方法是 final 的，返回的 EMPTY_LIST 也是 final 的，种种迹象表明 emptyList 返回的就是不可变对象，没法进行增伤改查。

1. public static final <T> List<T> emptyList() {
2.    return (List<T>) EMPTY_LIST;
3. }
5. public static final List EMPTY_LIST = new EmptyList<>();

5、其他

还有两个方法比较常用：

• addAll(Collection<? super T> c, T... elements)，往集合中添加元素
• disjoint(Collection<?> c1, Collection<?> c2)，判断两个集合是否没有交集

举个例子：

1. List<String> allList = new ArrayList<>();
2. Collections.addAll(allList, "九","十","二");
3. System.out.println("addAll 后：" + allList);
5. System.out.println("是否没有交集：" + (Collections.disjoint(list, allList) ? "是" : "否"));

输出后：

1. 原始顺序：[二, 三, 四, 五, 六]
2. addAll 后：[九, 十, 二]
3. 是否没有交集：否

整体上，Collections 工具类作为集合框架的大管家，提供了一些非常便利的方法。