Collections 包含用于操作集合的各种方法。
Collections 也提供了 sort() 和 binarySearch，sort() 底层使用的就是 Arrays.sort()，binarySearch() 底层使用的是自己重写的二分查找算法，实现逻辑和 Arrays.binarySearch() 完全一致。

求集合中最大值 & 最小值

max() 取集合中最大值，min() 取集合中最小值。
max 提供了两种类型的方法，一个需要传外部排序器，一个不需要传排序器，但需要集合中的元素强制实现 Comparable 接口
max() 的底层源码实现如下：

  1. public static <T> T max(Collection<? extends T> coll, 
  2.                         Comparator<? super T> comp) {
  3.     if (comp==null)
  4.         return (T)max((Collection) coll);
  6.     Iterator<? extends T> i = coll.iterator();
  7.     T candidate = i.next();
  9.     while (i.hasNext()) {
  10.         T next = i.next();
  11.         if (comp.compare(next, candidate) > 0)
  12.             candidate = next;
  13.     }
  14.     return candidate;
  15. }
  1. public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
  2.     Iterator<? extends T> i = coll.iterator();
  3.     // 最大值的候选人
  4.     T candidate = i.next();
  6.     while (i.hasNext()) {
  7.         T next = i.next();
  8.         if (next.compareTo(candidate) > 0)
  9.             candidate = next;
  10.     }
  11.     return candidate;
  12. }

从 max() 源码中，我们可以学习到两点：

  • 给我们提供了实现两种排序机制的好示例：自定义类实现 Comparable 接口和传入外部排序
    器。两种排序实现原理类似，但实现有所差别，如果需要写排序的工具类时，可以效仿
  • max() 泛型 T 定义得非常巧妙，意思是：泛型必须继承 Object 并且实现 Comparable 的接口

    一般让我们来定义的话，我们可以会在方法里面去判断有无实现 Comparable 的接口，这种是在运行时才能知道结果。 而这里泛型直接定义了必须实现 Comparable 接口，在编译的时候就可告诉使用者，当前类有没有实现 Comparable 接口，使用起来很友好。

多种类型的集合

Collections 对原始集合类进行了封装，提供了更好的集合类给我们，一种是线程安全的集合，一种是不可变的集合。
以下两种 List 其实解决了工作中的一些困惑，比如说 ArrayList 是线程不安全的，然后其内部数组很容易被修改，有时，我们希望 List 一旦生成后，就不能被修改，Collections 对 List 重新进行了封装，提供了两种类型的集合封装形式，从而解决了工作中的一些烦恼，如果你平时使用 List 时有一些烦恼，也可以学习此种方式，自己对原始集合进行封装，来解决 List 使用过程中的不方便。

线程安全的集合

线程安全的集合中方法都是 synchronized 打头的，底层是通过 synchronized 轻量锁来实现的 ，以 synchronizedList 为例来说明底层的实现

  1. static class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {
  2.     private static final long serialVersionUID = -7754090372962971524L;
  4.     // 这个 List 就是我们需要保证线程安全的集合
  5.     final List<E> list;
  7.     SynchronizedList(List<E> list) {
  8.         super(list);
  9.         this.list = list;
  10.     }
  11.     SynchronizedList(List<E> list, Object mutex) {
  12.         super(list, mutex);
  13.         this.list = list;
  14.     }
  16.     public boolean equals(Object o) {
  17.         if (this == o)
  18.             return true;
  19.         synchronized (mutex) {return list.equals(o);}
  20.     }
  21.     public int hashCode() {
  22.         synchronized (mutex) {return list.hashCode();}
  23.     }
  25.     public E get(int index) {
  26.         synchronized (mutex) {return list.get(index);}
  27.     }
  28.     public E set(int index, E element) {
  29.         synchronized (mutex) {return list.set(index, element);}
  30.     }
  31.     public void add(int index, E element) {
  32.         synchronized (mutex) {list.add(index, element);}
  33.     }
  34.     public E remove(int index) {
  35.         synchronized (mutex) {return list.remove(index);}
  36.     }
  38.     public int indexOf(Object o) {
  39.         synchronized (mutex) {return list.indexOf(o);}
  40.     }
  41.     public int lastIndexOf(Object o) {
  42.         synchronized (mutex) {return list.lastIndexOf(o);}
  43.     }
  45.     public boolean addAll(int index, Collection<? extends E> c) {
  46.         synchronized (mutex) {return list.addAll(index, c);}
  47.     }
  49.     public ListIterator<E> listIterator() {
  50.         return list.listIterator(); // Must be manually synched by user
  51.     }
  53.     public ListIterator<E> listIterator(int index) {
  54.         return list.listIterator(index); // Must be manually synched by user
  55.     }
  57.     public List<E> subList(int fromIndex, int toIndex) {
  58.         synchronized (mutex) {
  59.             return new SynchronizedList<>(list.subList(fromIndex, toIndex),
  60.                                           mutex);
  61.         }
  62.     }
  64.     @Override
  65.     public void replaceAll(UnaryOperator<E> operator) {
  66.         synchronized (mutex) {list.replaceAll(operator);}
  67.     }
  68.     @Override
  69.     public void sort(Comparator<? super E> c) {
  70.         synchronized (mutex) {list.sort(c);}
  71.     }
  73.     /**
  74.          * SynchronizedRandomAccessList instances are serialized as
  75.          * SynchronizedList instances to allow them to be deserialized
  76.          * in pre-1.4 JREs (which do not have SynchronizedRandomAccessList).
  77.          * This method inverts the transformation.  As a beneficial
  78.          * side-effect, it also grafts the RandomAccess marker onto
  79.          * SynchronizedList instances that were serialized in pre-1.4 JREs.
  80.          *
  81.          * Note: Unfortunately, SynchronizedRandomAccessList instances
  82.          * serialized in 1.4.1 and deserialized in 1.4 will become
  83.          * SynchronizedList instances, as this method was missing in 1.4.
  84.          */
  85.     private Object readResolve() {
  86.         return (list instanceof RandomAccess
  87.                 ? new SynchronizedRandomAccessList<>(list)
  88.                 : this);
  89.     }
  90. }

可以看到 List 的所有操作方法都被加上了 synchronized 锁，所以多线程对集合同时进行操作，是线程安全的。

不可变的集合

不可变的集合，只开放了查询方法，其余任何修改操作都会抛出异常。
以 unmodifiableList 为例来说明底层的实现：

  1. static class UnmodifiableList<E> extends UnmodifiableCollection<E> implements List<E> {
  2.     private static final long serialVersionUID = -283967356065247728L;
  4.     final List<? extends E> list;
  6.     UnmodifiableList(List<? extends E> list) {
  7.         super(list);
  8.         this.list = list;
  9.     }
  11.     public boolean equals(Object o) {return o == this || list.equals(o);}
  12.     public int hashCode()           {return list.hashCode();}
  14.     public E get(int index) {return list.get(index);}
  15.     public E set(int index, E element) {
  16.         throw new UnsupportedOperationException();
  17.     }
  18.     public void add(int index, E element) {
  19.         throw new UnsupportedOperationException();
  20.     }
  21.     public E remove(int index) {
  22.         throw new UnsupportedOperationException();
  23.     }
  24.     public int indexOf(Object o)            {return list.indexOf(o);}
  25.     public int lastIndexOf(Object o)        {return list.lastIndexOf(o);}
  26.     public boolean addAll(int index, Collection<? extends E> c) {
  27.         throw new UnsupportedOperationException();
  28.     }
  30.     @Override
  31.     public void replaceAll(UnaryOperator<E> operator) {
  32.         throw new UnsupportedOperationException();
  33.     }
  34.     @Override
  35.     public void sort(Comparator<? super E> c) {
  36.         throw new UnsupportedOperationException();
  37.     }
  39.     public ListIterator<E> listIterator()   {return listIterator(0);}
  41.     public ListIterator<E> listIterator(final int index) {
  42.         return new ListIterator<E>() {
  43.             private final ListIterator<? extends E> i
  44.                 = list.listIterator(index);
  46.             public boolean hasNext()     {return i.hasNext();}
  47.             public E next()              {return i.next();}
  48.             public boolean hasPrevious() {return i.hasPrevious();}
  49.             public E previous()          {return i.previous();}
  50.             public int nextIndex()       {return i.nextIndex();}
  51.             public int previousIndex()   {return i.previousIndex();}
  53.             public void remove() {
  54.                 throw new UnsupportedOperationException();
  55.             }
  56.             public void set(E e) {
  57.                 throw new UnsupportedOperationException();
  58.             }
  59.             public void add(E e) {
  60.                 throw new UnsupportedOperationException();
  61.             }
  63.             @Override
  64.             public void forEachRemaining(Consumer<? super E> action) {
  65.                 i.forEachRemaining(action);
  66.             }
  67.         };
  68.     }
  70.     public List<E> subList(int fromIndex, int toIndex) {
  71.         return new UnmodifiableList<>(list.subList(fromIndex, toIndex));
  72.     }
  74.     /**
  75.          * UnmodifiableRandomAccessList instances are serialized as
  76.          * UnmodifiableList instances to allow them to be deserialized
  77.          * in pre-1.4 JREs (which do not have UnmodifiableRandomAccessList).
  78.          * This method inverts the transformation.  As a beneficial
  79.          * side-effect, it also grafts the RandomAccess marker onto
  80.          * UnmodifiableList instances that were serialized in pre-1.4 JREs.
  81.          *
  82.          * Note: Unfortunately, UnmodifiableRandomAccessList instances
  83.          * serialized in 1.4.1 and deserialized in 1.4 will become
  84.          * UnmodifiableList instances, as this method was missing in 1.4.
  85.          */
  86.     private Object readResolve() {
  87.         return (list instanceof RandomAccess
  88.                 ? new UnmodifiableRandomAccessList<>(list)
  89.                 : this);
  90.     }
  91. }