2.2 Collections类（Collections源码解析)

2.2 Java.util.Collctions

这个类中的方法实在是太长了，挑一些经典的，面试也常常问道的问题出来讲讲!

2.2.1 为什么Collections中的静态方法可以让一个非线程安全的集合变成线程安全呢?

以synchronizedMap(Map<K,V> m)方法为例：

  public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {return new SynchronizedMap<>(m);}private static class SynchronizedMap<K,V>implements Map<K,V>, Serializable {private static final long serialVersionUID = 1978198479659022715L;private final Map<K,V> m;     // Backing Mapfinal Object      mutex;        // Object on which to synchronizeSynchronizedMap(Map<K,V> m) {this.m = Objects.requireNonNull(m);mutex = this;}SynchronizedMap(Map<K,V> m, Object mutex) {this.m = m;this.mutex = mutex;}public int size() {synchronized (mutex) {return m.size();}}public boolean isEmpty() {synchronized (mutex) {return m.isEmpty();}}public boolean containsKey(Object key) {synchronized (mutex) {return m.containsKey(key);}}//。。。省略很多方法

看源码，原来我们使用了该方法后，该类的类型变成了一个SynchronizedMap,并且将传入的map对象赋给了内部一个mutex对象，然后在该SynchronizedMap实现的所有方法都加上了synchronized (mutex),这个mutex不就是我们传入的原map吗?

原来如此，通过这样就实现了线程安全，其他对于List，Set的实现也和上述思路一样，不再赘述。

2.2.2 Collections的Unmodifiable操作如何实现的？

其实实现思路也和上述类似，看源码：

 static class UnmodifiableList<E> extends UnmodifiableCollection<E>implements List<E> {private static final long serialVersionUID = -283967356065247728L;final List<? extends E> list;UnmodifiableList(List<? extends E> list) {super(list);this.list = list;}//省略一堆
}

我们传入的集合是一个new出来的Unmodified集合，传入的集合用了一个final关键来修饰，是不是很简单就实现了不可变集合操作！

2.2.3 你了解Collections中的search方法吗?

先看代码：

首先先定义了一堆常量，该常量和具体使用的排序方法有关，该数值是一个经验上来的一个比较优的解法。

直白点儿说就是我这个集合大小会决定我用什么算法对它进行操作。

private static final int BINARYSEARCH_THRESHOLD   = 5000;
private static final int REVERSE_THRESHOLD        =   18;
private static final int SHUFFLE_THRESHOLD        =    5;
private static final int FILL_THRESHOLD           =   25;
private static final int ROTATE_THRESHOLD         =  100;
private static final int COPY_THRESHOLD           =   10;
private static final int REPLACEALL_THRESHOLD     =   11;
private static final int INDEXOFSUBLIST_THRESHOLD =   35;

就看一个binarySearch的一个方法，该方法实现思路是二分查找，所以入参的list必须继承自Comparable接口，这样其内部有序使用二分查找会很快，当然有序是使用binarySearch方法的条件。

public static <T>
int binarySearch(List<? extends Comparable<? super T>> list, T key) {if (list instanceof RandomAccess || list.size()<BINARYSEARCH_THRESHOLD)return Collections.indexedBinarySearch(list, key);elsereturn Collections.iteratorBinarySearch(list, key);
}private static <T>
int indexedBinarySearch(List<? extends Comparable<? super T>> list, T key) {int low = 0;int high = list.size()-1;while (low <= high) {int mid = (low + high) >>> 1;Comparable<? super T> midVal = list.get(mid);int cmp = midVal.compareTo(key);if (cmp < 0)low = mid + 1;else if (cmp > 0)high = mid - 1;elsereturn mid; // key found}return -(low + 1);  // key not found
}private static <T>
int iteratorBinarySearch(List<? extends Comparable<? super T>> list, T key)
{int low = 0;int high = list.size()-1;ListIterator<? extends Comparable<? super T>> i = list.listIterator();while (low <= high) {int mid = (low + high) >>> 1;Comparable<? super T> midVal = get(i, mid);int cmp = midVal.compareTo(key);if (cmp < 0)low = mid + 1;else if (cmp > 0)high = mid - 1;elsereturn mid; // key found}return -(low + 1);  // key not found
}

binarySearch()二分查找发的时候当这个List不是链表或者该链表长度小于5000的时候，使用indexedBinarySearch方法，否则使用iteratorBinarySearch方法。