ArrayList 和 LinkList 区别（源码分析）

• ArrayList 底层时动态数组 查找数据比较快，当执行 get（index）方法时，直接返回数组对应下表的元素 数组在内存存储时是一块连续的空间，知道首地址，当要查找第几个元素时，通过计算就能一次定位到该元素的地址
• LinkList 底层实现是双向链表，增加和删除元素比较快，链表的节点除了存储当前节点值外还存储上一个节点和下一个节点对象 当执行get（index）方法时，首先会判断 查找索引在前半段还是后半段，如果前半段，那就从第一个位置开始找，反之从最后一个找。
• Vector：底层方法和 ArrayList 大致一样，但是 Vector 扩容大小是 原来的2倍，并且修改方法添加了
  synchronized 关键字 是线程安全的

// ArrayList 

// 默认初始容量
 
private static final int DEFAULT_CAPACITY = 10;
 
// 用于空实例的共享空数组实例
 
private static final Object[] EMPTY_ELEMENTDATA = {};
//用于默认大小的空实例的共享空数组实例。我们将此与 EMPTY_ELEMENTDATA 区分开来，以了解在添加第一个元素时要膨胀多少。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 
// 真正存储元素的数组 
transient Object[] elementData;
 
//ArrayList的大小（它包含的元素的数量）

private int size;

//new ArrayList<>()  当new一个数组是 默认为空数组
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

// ArrayList 的 get 方法
public E get(int index) {
    //检查索引是否在范围内
    rangeCheck(index);
    return elementData(index);
}
E elementData(int index) {
    //返回索引为 index 的数组元素
    return (E) elementData[index];
}

// ArrayList 的 add 方法
public boolean add(E e) {
    // 扩容 第一次 size = 0
    ensureCapacityInternal(size + 1);
    // 第一次时 elementData[0] = e;  size++ 先返回 再+1
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 判断数组是否为空 第一次为空 minCapacity = 1 (参数size+1)
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 取最大值第一次  max(10,1) = 10
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
    // 数组被修改的次数，第一次为0
    modCount++;

    // minCapacity = 10  第一次 elementData 为空 第二次开始 elementData 长度标为10
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // minCapacity = 10  oldCapacity = 0
    int oldCapacity = elementData.length;
    // 右移一位相当于除以2  newCapacity 长度变为 oldCapacity  的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // 复制 elementData 所有元素 到长度为 newCapacity 的新数组 第一次复制后 elementData长度变为10
    elementData = Arrays.copyOf(elementData, newCapacity);
}

// LinkedList 

// LinkedList 存储了 元素个数 头节点 和  尾节点
public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;
    transient Node<E> first;
    transient Node<E> last;
}
// 节点
private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

--LinkLis 的 get 方法
public E get(int index) {
    checkElementIndex(index);
    return node(index).item;
}
Node<E> node(int index) {
    // assert isElementIndex(index);
    if (index < (size >> 1)) {
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}
// add
public boolean add(E e) {
    linkLast(e);
    return true;
}

void linkLast(E e) {
    //  尾节点赋给 临时节点
    final Node<E> l = last;
    // 新节点 的 pre=1, element=e, next=null
    final Node<E> newNode = new Node<>(l, e, null);
    // 尾节点为新节点
    last = newNode;
    // 集合没有元素
    if (l == null)
        //头节点为新节点
        first = newNode;
    else
        // 集合有元素，将新节点赋给 上一个元素的next
        l.next = newNode;
    size++;
    modCount++;
}