ArrayList 与 LinkedList性能比较

今天看到有人提问 arrayList 与 LinkedList 性能比较的问题,为此专门测试了下两者的插入,删除,访问效率
经过测试大概得出以下结论:
ArrayList 与 LinkedList 在顺序插入时(末尾插入),数据量较小时(100000以内)LinkedList的插入效率优于 arrayList(但不明显,最多几倍的差距),但数据量更大时(40w 以上)此时顺序插入 arraylist 的插入性能明显优于 linkedlist.但如果一直在 list 的位置0插入,linkedList 的插入性能对 arrayList 有指数级性能优势.
可以查看两者的插入代码分析以上现象:
先看 arrayList 的插入代码,主要代码如下:

 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);
    }
    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);
    }
    public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }

分析以上代码可以看到,arrayList 在顺序插入时,如果数据容量不够,会经常扩容,其中扩容代码Arrays.copyOf(elementData, newCapacity); 会消耗大量时间,但如果数据量较大,此时扩容次数明显下降(扩容总是会在当前容量的2倍),因此扩容消耗的时间平均下来明显降低,但对于每次都插入指定位置0的时候System.arraycopy(elementData, index, elementData, index + 1,size - index); 每次都会执行这个代码,数组的拷贝会浪费大量时间,因此插入时间会呈指数级增长

对于 linkedList,插入的主要代码逻辑如下:

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 = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }
   public void add(int index, E element) {
        checkPositionIndex(index);

        if (index == size)
            linkLast(element);
        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)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

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

可见对于末尾插入,linkedlist 每次打操作都是直接在链表末尾插入数据,对于位置0的插入,linkedlist 的操作与在末尾插入基本一致,(linkedlist 对于制定位置操作会首先检查靠近末尾还是靠近头元素,会从靠近的一端进行遍历),因此 linkedList 对于中间部分的插入操作的耗时会基本花在查找元素上

对于插入操作,两者可以得出以下结论:
1.对于少量元素,尽量使用 arrayList
2.对于大量元素(10w 以上),没有频繁的随机读取操作,且有大量的 list 前部的插入操作(前10%),此时可以选用 Linkedlist
3.尽量使用 arrayList,除非使用 LinkedList 时的速度是 arrayList 的10倍以上

对于删除操作:
对于大量数据,如果一直从 list 开始位置开始删除,linkedlist 对 arrayList 有指数级优势,但如果从末尾位置开始删除,arrayList 对 linkedList有较大优势
arraylist删除代码如下

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

主要耗时代码为:System.arraycopy(elementData, index+1, elementData, index, numMoved);,每一次删除 arrayList 都需要将被删除元素之后的所有元素复制一遍
对于 linkedList 的删除代码:

 public E remove(int index) {
        checkElementIndex(index);
        return unlink(node(index));
    }

  E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

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

对于 linkedList 来说删除的主要耗时还是花在查找元素上
因此对于删除操作这两者的建议如下:
对于少量数据的删除建议使用 arrayList
对于大量数据,总是删除靠前数据时,建议使用 linkedList
其余情况使用 arrayList

综合以上插入与删除,对于这两种 list 的综合建议:
99%的情况用ArrayList，还有1%的情况是：
1、超大List，超大指至少十几万个元素，并且还需要频繁添加删除(在 list 开始部分)，但不需要频繁访问
2、当你发现ArrayList比LinkedList耗时多一个数量级的时候