Java集合框架学习总结

集合的四个问题：
（1）是否可以为空
（2）是否允许重复数据
（3）是否有序
（4）是否线程安全

List（可以重复，有序）继承自Collection

（1）ArrayList（可以为空，可以重复数据，有序，线程不安全）：底层是Object[]数组，默认长度为10。
扩容机制：扩大为原来的1.5倍。

```java

```java
private void grow(int minCapacity)
{  
  ...
  int newCapacity = oldCapacity + (oldCapacity >> 1);
}

优点：适合有顺序的插入元素和随机访问的场景。
缺点：不适合随机插入和删除，因为会涉及到一次元素的复制，比较消耗性能。

（2）Vector(可以为空，可以重复数据，有序，线程安全（并非绝对）) : 底层是Object数组，默认长度为10。
线程安全：因为对外的方法中加了synchornized，但是并非绝对线程安全。
扩容机制：扩大为原来的2倍

```java
private void grow(int minCapacity) {
   ...
   int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                     capacityIncrement : oldCapacity);

（3）LinkedList（可以为空，可以重复数据，有序，线程不安全）：底层是基于双向链表实现的。
最好不要用普通for循环来遍历LinkedList数组，随机插入、删除时寻址慢但是插入和删除操作快。

java.util.concurrent：
CopyOnWriteArrayList（有序、可以为空、可以重复、线程安全）：底层是一个Object[]数组
线程安全的底层实现原理：
用add（）来举例

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();
        }
    }

先加锁，然后new一个新数组出来（并且新数组长度+1），把原来数组的元素复制到新数组中，保留最后一个空位置，留给要添加的元素，把Object Array指向新数组，解锁。
适用场景：（1）读写分离（读是操作原来的数组，写要新建一个数组操作）（2）最终一致
元素太多，写修改代价太大，因此适合读>写

Set(唯一)继承自Collection

（1）HashSet（元素唯一，插入无序（遍历时不会按照插入的顺序输出），可以为空，线程不安全）：底层采用HashMap来保存元素。
（2）LinkedHashSet（元素唯一，插入序，可以为空，线程不安全）：继承自HashSet，内部通过LinkedHashMap来实现。
（3）TreeSet(元素唯一，插入有序，不可以为空（会报空指针异常），线程不安全)：底层基于红黑树实现。

Map(以key-value的方式存储数据，通过key取value。key不能重复（key重复的话就会被覆盖），value可以)

（1）HashMap（key重复的话会覆盖，无序，key和value都可以为空，线程不安全）：底层基于数组+链表实现，jdk1.8以后如果链表长度大于阈值（默认为8），就会将链表打散成红黑树。
扩容：加载因子为0.75，当元素个数超过容量的0.75倍，就会进行扩容，扩容增量为原容量的2倍。
（2）Hashtable（key重复的话会被覆盖，无序，key和value都不能为空，线程安全）：底层基于数组+TreeMap（为了解决hash冲突过大）
Hashtable线程安全的原因是他对外的方法都加了sychornized
（3）LinkedHashMap（key重复的话会被覆盖，插入有序，key和value都可以为空，线程不安全）：继承自HashMap，在HashMap的基础上增加了双向链表保证插入的有序性（可以理解为HashMap+Linkedlist）

java.util.concurrent：
ConcurrentHashMap(key重复的话会被覆盖，无序，key和value都不能为空，线程安全)：底层实现，对每个segment加锁，所以线程安全，当链表中的元素超过8时，会转化为红黑树