【备战秋招】容器

容器主要包括 Collection 和 Map 两种，Collection 存储着对象的集合，而 Map 存储着 键值对（两个对象）的映射表。

Collection

Set

• TreeSet：基于红黑树实现，支持有序性操作，例如根据一个范围查找元素的操作。但是查找效率不如HashSet，HashSet查找的时间复杂度为 O(1)，TreeSet 则为 O(logN)。
• HashSet：基于哈希表实现，支持快速查找，但不支持有序性操作。并且失去了元素的插入顺序信息，也就是说使用 Iterator遍历 HashSet 得到的结果是不确定的。
• LinkedHashSet：具有HashSet 的查找效率，且内部使用双向链表维护元素的插入顺序。

List

• ArrayList：基于动态数组实现，支持随机访问。
• Vector：和 ArrayList 类似，但它是线程安全的。
• LinkedList：基于双向链表实现，只能顺序访问，但是可以快速地在链表中间插入和删除元素。不仅如此，LinkedList 还可以用作栈、队列和双向队列。

Queue

• LinkedList：可以用它来实现双向队列。
• PriorityQueue：基于堆结构实现，可以用它来实现优先队列。

---

Map

• TreeMap：基于红黑树实现。
• HashMap：基于哈希表实现。
• HashTable：和 HashMap类似，但它是线程安全的，这意味着同一时刻多个线程可以同时写入 HashTable 并且不会导致数据不一致。它是遗留类，不应该去使用它。现在可以使用 ConcurrentHashMap来支持线程安全，并且 ConcurrentHashMap 的效率会更高，因ConcurrentHashMap 引入了分段锁。
• LinkedHashMap：使用双向链表来维护元素的顺序，顺序为插入顺序或者最近最少使用（LRU） 顺序。

容器中的相关设计模式

• 迭代器模式
  提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
  
  Collection 继承了 Iterable 接口，其中的 iterator()方法能够产生一个 Iterator 对象，通过这个对象就可以迭代遍历Collection 中的元素。
• 适配器模式
  将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

@SafeVarargs 
public static <T> List<T> asList(T... a) 
//使用
Integer[] arr = {1, 2, 3}; 
List list = Arrays.asList(arr);
//
List list = Arrays.asList(1, 2, 3);

ArrayList

public class ArrayList<E> extends AbstractList<E> 
implements List<E>, RandomAccess, Cloneable, java.io.Serializable

数组的默认大小为 10。

 private static final int DEFAULT_CAPACITY = 10;

扩容
添加元素时使用 ensureCapacityInternal()方法来保证容量足够，如果不够时，需要使用grow()方法进行扩容，新容量的大小为 oldCapacity + (oldCapacity >> 1)，也就是旧容量的 1.5 倍。
扩容操作需要调用Arrays.copyOf()把原数组整个复制到新数组中，这个操作代价很高，因此最好在创建ArrayList 对象时就指定大概的容量大小，减少扩容操作的次数。

删除
需要调用System.arraycopy()将 index+1 后面的元素都复制到 index `位置上，该操作的时间复杂度为 O(N)，可以看出 ArrayList 删除元素的代价是非常高的。

Fail-Fast
modCount 用来记录 ArrayList 结构发生变化的次数。结构发生变化是指添加或者删除至少一个元素的所有操作，或者是调整内部数组的大小，仅仅只是设置元素的值不算结构发生变化。

序列化
ArrayList 基于数组实现，并且具有动态扩容特性，因此保存元素的数组不一定都会被使用，那么就没必要全部进行序列化。
保存元素的数组 elementData 使用 transient 修饰，该关键字声明数组默认不会被序列化。

transient Object[] elementData;

Vector

public synchronized boolean add(E e) { 
	modCount++; 
	ensureCapacityHelper(elementCount + 1);   
    elementData[elementCount++] = e; 
    return true; 
}

Vector 是同步的，因此开销就比ArrayList要大，访问速度更慢。最好使用 ArrayList而不是Vector，因为同步操作完全可以由程序员自己来控制；
Vector 每次扩容请求其大小的 2 倍空间，而 ArrayList 是 1.5 倍。

替代方案

List<String> list = new ArrayList<>(); 
List<String> synList = Collections.synchronizedList(list);

CopyOnWriteArrayList

读写分离
写操作在一个复制的数组上进行，读操作还是在原始数组中进行，读写分离，互不影响。
写操作需要加锁，防止并发写入时导致写入数据丢失。
写操作结束之后需要把原始数组指向新的复制数组。

public boolean add(E e) { 
   final ReentrantLock lock = this.lock; 
   lock.lock(); 
   try {
      Object[] elements = getArray(); 
      int len = elements.length; 
      Object[] newElements = Arrays.copyOf(elements, len + 1);  
      newElements[len] = e; 
      setArray(newElements); 
      return true; 
    } 
  finally {
     lock.unlock(); 
  }
}
  final void setArray(Object[] a) { 
         array = a;
   }

CopyOnWriteArrayList在写操作的同时允许读操作，大大提高了读操作的性能，因此很适合读多写少的应用场景。

LinkedList

private static class Node<E> { 
	E item; 
	Node<E> next; 
	Node<E> prev; 
} 

transient Node<E> first; 
transient Node<E> last; 

• ArrayList 基于动态数组实现，LinkedList 基于双向链表实现；
• ArrayList 支持随机访问，LinkedList 不支持；
• LinkedList 在任意位置添加删除元素更快。

HashMap

内部包含了一个 Entry 类型的数组 table。

transient Entry[] table;

Entry 是一个链表.HashMap 使用拉链法来解决冲突，同一个链表中存放哈希值和散列桶取模运算结果相同的 Entry。到链表的插入是以头插法方式进行的

Entry(int h, K k, V v, Entry<K,V> n) { 
	value = v; 
	next = n; 
	key = k; 
	hash = h; 
}

HashMap 允许插入键为 null 的键值对。但是因为无法调用 null 的 hashCode()方法，也就无法确定该键值对的桶下标，只能通过强制指定一个桶下标来存放。HashMap 使用第 0 个桶存放键为 null 的键值对。

使用链表的头插法，也就是新的键值对插在链表的头部，而不是链表的尾部。

确定桶下标

int hash = hash(key); 
int i = indexFor(hash, table.length);

计算hash值

final int hash(Object k) { 
int h = hashSeed; 
if (0 != h && k instanceof String) { 
   return sun.misc.Hashing.stringHash32((String) k); 
}
	h ^= k.hashCode(); 
	h ^= (h >>> 20) ^ (h >>> 12); 
	return h ^ (h >>> 7) ^ (h >>> 4); 
}

计算数组容量

static final int tableSizeFor(int cap) { 
	int n = cap - 1; 
	n |= n >>> 1; 
	n |= n >>> 2; 
	n |= n >>> 4; 
	n |= n >>> 8; 
	n |= n >>> 16; 
	return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; 
}

从 JDK 1.8 开始，一个桶存储的链表长度大于 8 时会将链表转换为红黑树。

与 HashTable 的比较

• HashTable 使用 synchronized 来进行同步。
• HashMap 可以插入键为 null 的 Entry。
• HashMap 的迭代器是 fail-fast 迭代器。
• HashMap 不能保证随着时间的推移 Map 中的元素次序是不变的。

ConcurrentHashMap

ConcurrentHashMap 和HashMap 实现上类似，最主要的差别是 ConcurrentHashMap 采用了分段锁（Segment），每个分段锁维护着几个桶（HashEntry），多个线程可以同时访问不同分段锁上的桶，从而使其并发度更高（并发度就是 Segment 的个数）。

final Segment<K,V>[] segments;
static final int DEFAULT_CONCURRENCY_LEVEL = 16;

在执行 size 操作时，需要遍历所有 Segment 然后把 count 累计起来。
ConcurrentHashMap 在执行 size 操作时先尝试不加锁，如果连续两次不加锁操作得到的结果一致，那么可以认为这个结果是正确的。

JDK 1.7 使用分段锁机制来实现并发更新操作，核心类为 Segment，它继承自重入锁 ReentrantLock，并发度与Segment数量相等。
JDK 1.8 使用了 CAS 操作来支持更高的并发度，在 CAS 操作失败时使用内置锁synchronized。并且 JDK 1.8 的实现也在链表过长时会转换为红黑树

LinkedHashMap

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

内部维护了一个双向链表，用来维护插入顺序或者 LRU 顺序。

LinkedHashMap 最重要的是以下用于维护顺序的函数，它们会在 put、get 等方法中调用。

void afterNodeAccess(Node<K,V> p) { } 
void afterNodeInsertion(boolean evict) { }

LRU缓存
以下是使用 LinkedHashMap 实现的一个 LRU 缓存：

• 设定最大缓存空间 MAX_ENTRIES 为 3；
• 使用 LinkedHashMap 的构造函数将accessOrder设置为true，开启 LRU 顺序；
• 覆盖 removeEldestEntry() 方法实现，在节点多于MAX_ENTRIES 就会将最近最久未使用的数据移除。

WeakHashMap

WeakHashMap 的 Entry 继承自WeakReference，被 WeakReference关联的对象在下一次垃圾回收时会被回收。
WeakHashMap 主要用来实现缓存，通过使用 WeakHashMap 来引用缓存对象，由 JVM 对这部分缓存进行回收。

Tomcat 中的 ConcurrentCache 使用了 WeakHashMap 来实现缓存功能。
ConcurrentCache 采取的是分代缓存：

• 经常使用的对象放入 eden 中，eden 使用 ConcurrentHashMap实现，不用担心会被回收；
• 不常用的对象放入longterm，longterm 使用WeakHashMap 实现，这些老对象会被垃圾收集器回收。
• 当调用 get() 方法时，会先从 eden 区获取，如果没有找到的话再到longterm 获取，当从longterm 获取到就把对象放入 eden 中，从而保证经常被访问的节点不容易被回收。
• 当调用 put() 方法时，如果 eden 的大小超过了 size，那么就将 eden中的所有对象都放入longterm中，利用虚拟机回收掉一部分不经常使用的对象。