ArrayList与LinkedList源码分析

本文要解决的问题：

通过对ArrayList与LinkedList的源码进行分析，以便对这两种集合有更加深入的理解。

ArrayList

也叫数组列表，底层使用的数组实现的，严格来说是动态数组。为了简化，我将从以下几个方面对ArrayList进行分析，目录结构如下：

• ArrayList的原理
• 源码分析

ArrayList工作原理

ArrayList工作原理其实很简单，底层是动态数组，每次创建一个ArrayList实例时会分配一个初始容量（如果指定了初始容量的话），以add方法为例，如果没有指定初始容量，当执行add方法，先判断当前数组是否为空，如果为空则给保存对象的数组分配一个最小容量，这里为10。当添加大容量元素额时候，会先增加数组的大小，以提高添加的效率。

把ArrayList理解为一个数组就好了

源码分析

由于ArrayList方法较多，对源码的分析不能一一到位，所以选取了我们平时最常用的add、get和remove方法来分析。

add方法

add方法重载了多个实现，包括add(E e)和add(int index,E e)，由于没有指定插入的位置，每次插入操作会把元素放到数组的末尾，而这个过程只需要保证容量够用就行，先来看看add(E e)方法：

public boolean add(E e) {
    //保证数组的容量始终够用
    ensureCapacityInternal(size + 1);
    //size是elementData数组中元组的个数，初始为0
    elementData[size++] = e;
    return true;
}
private void ensureCapacityInternal(int minCapacity) {
    //如果数组没有元素，给数组一个默认大小，会选择实例化时的值与默认大小中较大值
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //保证容量够用
    ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
    //modCount是数组发生size更改的次数
    modCount++;
    // 如果数组长度小于默认的容量10，则调用扩大数组大小的方法
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

下面看看add(int index,E e):

public void add(int index, E element) {
    //判断index的值是否合法，如果大于size或者小于0则将抛出异常
    rangeCheckForAdd(index);
    //保证容量够用，并修改modCount的值
    ensureCapacityInternal(size + 1); 
    //从第index位置开始，将元素往后移动一个位置
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    //把要插入的元素e放在第index位置
    elementData[index] = element;
    //数组元素的个数增加1
    size++;
}

get方法

get方法最简单，首先判断该位置是否合法，如果合法则直接返回该位置的元素

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

remove方法

由于删除操作会改变size，所以每次删除都需要把元素向前移动一个位置，然后把原来最后一个位置的元素设置为null，一次删除操作完成。下面看看源码：

public E remove(int index) {
    //判断index是否合法
    rangeCheck(index);
    //remove操作会改变size，所以modCount加1
    modCount++;
    //保存待删除位置的元素
    E oldValue = elementData(index);
    //要移动的元素个数
    int numMoved = size - index - 1;
    //如果index不是最后一个元素，则从第index+1到最后一个位置，依次向前移动一个位置
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    //元素的size减少1，并把原来末尾位置元素的值设置为null
    elementData[--size] = null; 
    //返回index位置的值
    return oldValue;
}

可以注意到源码调用了System.arraycopy方法，该方法是native的，即该代码是其他语言编写，但Java允许与其进行交互（详情请搜索JNI），那么该方法是如何让实现的呢？

//add方法的System.arraycopy()
//把从第i位置的元素开始到最后一个元素，都往后移动一个位置
for(int j = size - 1; j > i; j--){
    elements[j] = elements[j-1];
}
//把第i位置的值改为e
elements[i] = e;

//remove方法的System.arraycopy()方法
//把从第i位置到最后一个位置，都向前移动一个位置
for (int j = i; j < size - 1; j++) {
    elements[j] = elements[j + 1];
}
//把数组的元素个数减少1
elements[--size] = null;

ArrayList小结

通过以上代码的分析，可以总结以下几点：

• get方法的时间复杂度为O(1)，add和remove操作的时间复杂度为O(n)
• 在ArrayList中查找元素很方便，但插入以及删除元素效率就很低，移动元素对性能的开销很大
• ArrayList是非同步的
• ArrayList一般应用于查询较多但插入以及删除较少情况，如果插入以及从删除较多则建议使用LinkedList

LinkedList

LinkedList原理

LinkedList底层使用的双端链表，即每个节点既包含指向其后继的引用也包括指向其前驱的引用，LinkedList实现了List接口，继承了AbstractSequentialList类，在频繁进行插入以及删除的情况下效率较高。

源码分析

LinkedList使用较多哦也是add、get和remove，源码的分析也将对这三个方法进行分析

add

先看add方法：

public boolean add(E e) {
    //把e放在链表的最后一个位置
    linkLast(e);
    return true;
}
void linkLast(E e) {
    //last是链表最后一个节点的引用，现在l也指向最后一个节点
    final Node<E> l = last;
    //调用Node(Node<E> prev, E element, Node<E> next)构造方法
    final Node<E> newNode = new Node<>(l, e, null);
    //last节点指向newNode
    last = newNode;
    //如果l为空，则链表为空，直接把newNode链接在首节点后面即可，否则把newNode链接//在l节点的后面
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    //链表的元素个数增加1
    size++;
    //modCount是链表发生结构性修改的次数（结构性修改是指发生添加或者删除操作）
    modCount++;
}

可以看出，插入一个节点非常快，直接找到该位置的节点，修改节点的前驱以及后继的引用即可

get

下面看看get方法：

public E get(int index) {
    //检查index是否合法
    checkElementIndex(index);
    //如果合法就返回该节点位置的值
    return node(index).item;
}
//获取index位置上的节点
Node<E> node(int index) {
    //断言index在链表中
    // assert isElementIndex(index);
    //从第一个节点开始寻找直到index位置，然后返回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;
    }
}
//检查index值的合法性
private void checkElementIndex(int index) {
    if (!isElementIndex(index))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//判断index是否存在于链表中
private boolean isElementIndex(int index) {
    return index >= 0 && index < size;
}

可以看出获取index节点的值要从头或尾遍历链表，当数据量很大的时候，效率无疑是低下的

remove

最后看看remove操作：

public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}
E unlink(Node<E> x) {
    // assert x != null;
    //保存x节点的值
    final E element = x.item;
    //保存x节点的后继
    final Node<E> next = x.next;
    //保存x节点的前驱
    final Node<E> prev = x.prev;
    //如果前驱为null，说明要移除的是第一个节点，把First指向下一个节点就行
    if (prev == null) {
        first = next;
    } else {//否则，把x节点前驱的后继指向x的后继，并把x的前驱设置为null
        prev.next = next;
        x.prev = null;
    }
    //如果后继为null则要移除的是最后一个节点，则把last的引用指向x节点的前驱就ok
    if (next == null) {
        last = prev;
    } else {//否则，把x节点的后继的前驱设置为x节点的前驱，并x节点的后继设为null
        next.prev = prev;
        x.next = null;
    }
    //把x节点的值设为null，这样x就没有任何引用了，gc处理
    x.item = null;
    //把链表的size减少1
    size--;
    //结构性修改的次数增加1
    modCount++;
    //返回x节点的值，在移除之前已经保存在element中了
    return element;
}

LinkedList小结

通过以上源码的分析，可以总结如下几点：

• get方法的时间复杂度为O(n),add和remove的时间复杂度为O(1)，因为只需要修改节点的前驱以及后继就可以
• LinkedList是非同步的，如果要考虑并发，则需要使用外部同步
• LinkedList一般应用于增删较多而查找较少的情况，从时间复杂度上便可以看出来

ArrayList与LinekdList的区别

简单来讲，可以概括为以下几点：

• ArrayList底层使用的数据结构是数组而LinekdList底层使用的是双端链表
• ArrayList查询效率较高而LinkedList增删效率较高
• ArrayList应用于查找操作较多的场景中而LinkedList应用于增删较多的场景中
• 对于随机访问get和set还是ArrayList更好
• ArrayList对空间的开销主要体现在总要给尾部预留一定的空间，而LinkedList的开销主要体现在要为每个元素占用较多空间