List集合详解

---

一、ArrayList

特点：

• ArrayList底层是动态数组，区别于普通数组是可以动态扩容；
• 数组是有索引值的，所以ArrayList的查询快，理论上插入和删除是比较慢的，但是其底层是有做一些优化的；

插入：当我们new ArrayList的时候，默认有一个空的Object数组，大小为0，在第一次Add的时候，会给这个数组一个初始容量为10；

/**
* 用于空实例的共享空数组实例，在new ArrayList（）的时候实例化
*/
 private static final Object[] EMPTY_ELEMENTDATA = {};

/**
*  构造器给数组赋予初始值，初始化为空
**/
 public ArrayList(int initialCapacity) {
   if (initialCapacity > 0) {
       this.elementData = new Object[initialCapacity];
   } else if (initialCapacity == 0) {
       this.elementData = EMPTY_ELEMENTDATA;
   } else {
       throw new IllegalArgumentException("Illegal Capacity: "+
                                      initialCapacity);
   }
}

/**
* 在调用add方法时会判断数组容量大小，第一次比较小于默认容量则给数组扩容为10；
**/
public boolean add(E e) {
   ensureCapacityInternal(size + 1);  // Increments modCount!!
   elementData[size++] = e;
   return true;
}

private void ensureCapacityInternal(int minCapacity) {
   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
       minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
   }
   ensureExplicitCapacity(minCapacity);
}
/**
* 判断数组容量是否足够，调用grow进行扩容
**/
private void ensureExplicitCapacity(int minCapacity) {
   modCount++;
   // overflow-conscious code
   if (minCapacity - elementData.length > 0)
       grow(minCapacity);
}

扩容：ArrayList的添加数据时扩容原数组的1.5倍,在扩容过程中，如果数组扩容太小不适用则把扩容大小给newCapacity ；

   private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

数据拷贝：空间扩完容之后，会调用arraycopy来对数组进行拷贝，由于CPU底层对arraycopy进行优化过所以ArrayList增删并不慢；

public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew, numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

线程安全问题:

ArrayList线程不安全会出现如下问题

• 值为null
• 线程未答应
• 数组下标越界异常

解决方案：

• List接口中的Vector是线程安全的类相对于ArrayList，它是线程安全的，在扩容的时候它是直接扩容两倍的，比如现在有10个元素，要扩容的时候，就会将数组的大小增长到20，但是我们很少用；
• 使用JUC中的CopyOnWriteArrayList

CopyOnWriteArrayList arrayList=new CopyOnWriteArrayList();

• 使用Collections.synchronizedList

  List<Object> objects = Collections.synchronizedList(new ArrayList<>());

二、LinkedList

特点：

• LinkedList类是双向列表, Entry是双向链表节点所对应的数据结构，它包括的属性有：当前节点所包含的值，上一个节点，下一个节点。
• 从LinkedList的实现方式中可以发现，它不存在LinkedList容量不足的问题。
• LinkedList的克隆函数，即是将全部元素克隆到一个新的LinkedList对象中。
• LinkedList实现java.io.Serializable。当写入到输出流时，先写入“容量”，再依次写入“每一个节点保护的值”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。

线程安全问题

• Collections.synchronizedList(new LinkedList())
• LinkedList和ArrayList换成线程安全的集合，如CopyOnWriteArrayList，ConcurrentLinkedQueue…
• Vector(内部主要使用synchronized关键字实现同步)