【java集合类】ArrayList和LinkedList源码分析（jdk1.8）

前言：

　　ArrayList底层是依靠数组实现的，而LinkedList的实现是含前驱后继节点的双向列表。平时刷题时会经常使用到这两个集合类，这两者的区别在我眼中主要是ArrayList读取节点平均时间复杂度是O（1）级别的，插入删除节点是O（n）；LinkedList读取节点时间复杂度是O（n），插入节点是O（1）。

　　本文记录我对jdk1.8下的ArrayList和LinkedList源码中主要内容的学习。

1、ArrayList

1.1 主要成员变量

    //默认容量
    private static final int DEFAULT_CAPACITY = 10;
    //空的数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    //数据数组
    transient Object[] elementData; // non-private to simplify nested class access
    //当前大小
    private int size;

　　主要成员变量如上，最重要的就是size和elementData，其中elementData的修饰transient一开始很令我费解，查阅资料后豁然开朗，transient是为了序列化ArrayList时不用Java自带的序列化机制，而用ArrayList定义的两个方法（writeObject、readObject），实现自己可控制的序列化操作，防止数组中大量NULL元素被序列化。

1.2 主要方法

1.2.1 构造方法

　　构造方法源码其实很简单，不过在此提及是为了给后面扩容引出一个思考。

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

   
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

　　源码如上，一个不带参数的构造器，以及带容量参数的构造器。

1.2.2 add方法

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

    //判断是否需要扩容
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

　　add方法中先用ensureCapacityInternal方法，首先判断是否位第一次add，也就是初始化。如果数组位空，那么DEFAULT_CAPACITY就是为10。然后判断是否需要扩容，如果原size+1比数组的length大就需要扩容。（扩容）后把要加的元素加到末尾即可。

1.2.3 扩容方法（grow）

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

　　扩容方法如上，hugeCapacity判断minCapacity是否大于ArrayList上限，如果大于就返回ArrayList的容量上限。用Arrays.copyof新生成一个数组，而newCapacity = oldCapacity + (oldCapacity >> 1)则是将容量变为原来的1.5倍。

　　因为ArrayList默认初始容量为10，每次扩容将容量变为1.5倍，而如果使用ArrayList时要一次性add100个元素，则会频繁用调用扩容方法，因此可以在初始化ArrayList时使用带参的构造函数，定一个合适的容量值。

1.2.4 remove方法

    public E remove(int index) {
        rangeCheck(index);

        modCount++;
        E oldValue = elementData(index);

        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }

　　remove方法主要有两种，一种是根据下标remove，另一种是根据传入的元素匹配删除第一个遇到的该元素，值得一提的是可以删除null元素（总感觉怪怪的）。

2、LinkedList

　　LinkedList是一个双向链表，可以当（双端）队列用。

2.1 主要成员变量

    transient int size = 0;
    
    //头节点
    transient Node<E> first;

    //尾节点
    transient Node<E> last;

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

　　带首尾的双向列表，加一个size变量记录当前节点数量，transient修饰和ArrayList中修饰数组的原因是一样的，同样实现了writeObject和readObject，自己实现把size和每一个节点都序列化和反序列化了。

2.2 主要方法

2.2.1 add方法

    //add方法添加元素到末尾
    public boolean add(E e) {
        linkLast(e);
        return true;
    }
    
    //添加元素至末尾
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);//新建元素，把前驱节点置为原来的last节点
        last = newNode;
        if (l == null)//如果尾节点是空（说明头节点也是空的），就把头节点设置成新节点
            first = newNode;
        else//原来尾节点的后继设置成新节点
            l.next = newNode;
        size++;
        modCount++;
    }

　　一种add就是上面代码的加到末尾，分析都在注释中了。另一种则是添加到指定index，add的平均时间复杂度为O（n）。

    public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);//index是最后一个就直接插到最后
        else
            linkBefore(element, node(index));
    }

    //将节点插入到目标节点前面
    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;
        final Node<E> newNode = new Node<>(pred, e, succ);//将插入节点的前驱设置成目标节点的前驱
        succ.prev = newNode;
        if (pred == null)//同linkLast中设置后驱节点为目标节点
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

2.2.2 remove方法

　　remove方法和add方法类似，由于是双端队列，因此需要改变删除节点的前驱和后继节点的后继和前驱。在此不再展开描述。

2.2.3 get方法

　　get方法在此不贴源码了，由于是双端队列，因此如果查找的下标大于size的一半，就从后面往前遍历，虽然时间复杂度还是o（n）级别的，不过也算是一个小优化吧。

　　本篇简略的对jdk1.8下的ArrayList和LinkedList源码实现进行了分析，期间被几个命名奇怪的方法勾引走了，比如ArrayList的trimToSize，可以将数组多余的（大于size）的部分“删掉”。也学到了不少（emmm，好像没有特别多）东西。本篇博客算是对学习过程的一个记录吧。（才不会说是好久没更新博客了要懒死了QAQ）。