ArrayList 和 LinkedList源码分析

• ArrayList 
   

• ArrayList 底层右数组实现，初始化ArrayList后默认创建一个为空的数组，在第一添加元素时候 会扩容为长度为10的数组，后续扩容将以原来的数据的1.5倍进行扩容

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
    //默认容量
    private static final int DEFAULT_CAPACITY = 10;
    //初始化Object 类型空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //Object数组 
    transient Object[] elementData; 
    //数组长度
    private int size;

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    //无参构造方法
    public ArrayList() {
        //默认初始化为空的Object数组
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    //添加元素方法
    public boolean add(E e) {
        //确保容量够大
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //赋值并 将 size加1
        elementData[size++] = e;
        return true;
    }
    //确保容量
    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    //计算容量
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        //判断容量元素是否是空
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            //比较默认容量和最小容量并返回最大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    //判断需不需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        //当数组长度不够长时扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        // 获取当前数组长度
        int oldCapacity = elementData.length;
        //计算获得新数组长度 (X+(x/2))即原来的1.5倍长度
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //如果计算的到长度小于最小容量则按照最小容量扩容
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //将扩容后的新数组copy上数据，指针指向elementData 
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
     private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow 
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;
    }
}

• 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() {
    }

    private static class Node<E> {
        E item;//当前元素
        Node<E> next;//前一个元素
        Node<E> prev;//后一个元素
        //构造Node对象
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
    //获取列表长度
    public int size() {
        return size;
    }
    //添加元素
    public boolean add(E e) {
        linkLast(e);
        return true;
    }

    void linkLast(E e) {
        //队尾节点赋值l
        final Node<E> l = last;
        //调用构造方法返回Node对象
        final Node<E> newNode = new Node<>(l, e, null);
        //将添加元素设置为最后一个节点
        last = newNode;
        //判断是否是第一个节点添加
        if (l == null)
            //将队列头设置给当前添加元素
            first = newNode;
        else
            //队尾的下一个指针指向添加的节点
            l.next = newNode;
        //增加队列长度
        size++;
        modCount++;
    }

}

总结：

1、数据结构不同

ArrayList是Array(动态数组)的数据结构，LinkedList是Link(链表)的数据结构。

2、效率不同

当随机访问List（get和set操作）时，ArrayList比LinkedList的效率更高，因为LinkedList是线性的数据存储方式，所以需要移动指针从前往后依次查找。
当对数据进行增加和删除的操作(add和remove操作)时，LinkedList比ArrayList的效率更高，因为ArrayList是数组，所以在其中进行增删操作时，会对操作点之后所有数据的下标索引造成影响，需要进行数据的移动。

3、自由性不同

ArrayList自由性较低，因为它需要手动的设置固定大小的容量，但是它的使用比较方便，只需要创建，然后添加数据，通过调用下标进行使用；而LinkedList自由性较高，能够动态的随数据量的变化而变化，但是它不便于使用。

4、主要控件开销不同

ArrayList主要控件开销在于需要在lList列表预留一定空间；而LinkList主要控件开销在于需要存储结点信息以及结点指针信息。