深入底层：ArrayList、LinkedList源码理解

一、ArrayList

ArrayList底层是一个长度可以动态增长的Object数组

	public class ArrayList<E> extends AbstractList<E> implements 
	List<E>, RandomAccess, Cloneable, Serializable{
	       private static final int DEFAULT_CAPACITY = 10; 
	       private static final Object[] EMPTY_ELEMENTDATA = {};
	       private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
	       transient Object[] elementData;
	       private int size;
	}

JDK7时，使用无参数构造方法创建ArrayList对象时，默认数组长度为10
JDK8时，使用无参数构造方法创建ArrayList对象时，默认数组长度为空
当第一次添加数据的长度不超过10时，第一次扩容默认为10。

	private static int calculateCapacity(Object[] elementData, int minCapacity) {
		if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
			return Math.max(DEFAULT_CAPACITY, minCapacity);
		}
		return minCapacity;
	}

当容量不够，进行扩容时，默认扩容50%，如果扩容50%还不满足容纳新增的元素，就扩容为能容纳新增元素的最小数量

    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);
        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;	//指向尾节点
    public LinkedList() {
    }
}

有一个静态内部类Node，表示双向链表的节点

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

首尾节点指向示例图：