源码分析二(ArrayList与LinkedList的区别)

一：首先看一下ArrayList类的结构体系：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

继承AbstractList抽象类，实现List接口、序列化接口等。

它的底层维护了一个Object[]数组，或者可以说它的底层数据结构是数组

/**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer.
     */
    private transient Object[] elementData;

而LinkedList结构体系：

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

也是实现了List接口，但是它的底层数据结构表示数组，而是链式结构，内部维护一个相当于指针的Entry类

private transient Entry<E> header = new Entry<E>(null, null, null);
    private transient int size = 0;

 private static class Entry<E> {
    E element;
    Entry<E> next;
    Entry<E> previous;

    Entry(E element, Entry<E> next, Entry<E> previous) {
        this.element = element;
        this.next = next;
        this.previous = previous;
    }
    }

这里暂且称呼它为指针，这个指针维护了三个成员变量，第一个是元素、后面两个是当前元素的前一个指针和后一个指针。

二：ArrayList读取数据效率高于LinkedList

直接上源码：

 public E get(int index) {
    RangeCheck(index);

    return (E) elementData[index];
    }

很简单，第一个校验参数，第二步根据索引直接到数组中查询元素返回，所以ArrayList读取数据的效率是固定的

校验参数的源码也贴一下，如下：

private void RangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);
    }

如果指定索引的值大于等于集合的长度，那么会抛出角标越界异常。(注意：数组的最后一个元素index=size-1)

而LinkedList读取元素的方式：

public E get(int index) {
        return entry(index).element;
    }

根据指定index获取指针，因为指针中维护元素信息，那么咱们就来看一下指针的获取方式：

 private Entry<E> entry(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Entry<E> e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else {
            for (int i = size; i > index; i--)
                e = e.previous;
        }
        return e;
    }

首先第一步还是参数校验，如果索引小于0或者大于等于size，抛空指针异常，然后从header指针开始寻找目标

这里注意一下，为了提高查找效率，有个判断size>>1 就是右移两位(除以2)，意思就是索引的位置如果在前半段

就从前往后找，如果index的位置是后半段，就从后往前找，直到找到index索引位置结束，返回指针。因为指针中

只维护了它的前一个指针和后一个指针，所以只能一个一个的往前(后)找，不能绕过，所以效率自然就低于ArrayList。

三：ArrayList操作数据(增加或者删除)效率低于LinkedList

首先看ArrayList的add():

 public boolean add(E e) {
    ensureCapacity(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
    }

如果仅仅只是add，那么很简单，第一步扩容，然后将新增的元素放到最后一个元素的后面，返回true。

但是如果将元素插入到指定index位置时，就有些麻烦了：

  public void add(int index, E element) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);

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

第一步还是参数校验，索引位置不能小于0或者大于集合中元素数量，第二步扩容，然后将index位置包括以后元素

整体向后移动一个位，这样就把数组中index位置给空出来了，于是将element放到index为，集合中元素数量加一，

这里有移动数据的操作，所以效率比较低。

再来看一看ArrayList的remove操作，与add(int index,E element)的操作大致类似：

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

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

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

    return oldValue;
    }

第一步参数校验，index不能超过size，第二步获取index位置元素，暂且存储，然后将index+1以及后面的元素整体

向前移动一位，这样index位置的元素就被index+1给替换了，而size-1位置元素和size-2相等，需要置为null，等待垃圾回收器处理，

然后将index位置元素返回，这个过程又涉及到移动数组中的数据，所以效率比较低。

来看看LinkedList是怎么处理插入和删除的:

 public void add(int index, E element) {
        addBefore(element, (index==size ? header : entry(index)));
    }

add(int index,E element)调用了addBefore这个方法，如果index==size，那么指针就是head，如果不是就会根据index

查找对应的指针，意思就是要将元素插入到哪个位置。

private Entry<E> addBefore(E e, Entry<E> entry) {
    Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
    newEntry.previous.next = newEntry;
    newEntry.next.previous = newEntry;
    size++;
    modCount++;
    return newEntry;
    }

首先创建并初始化指针newEntry，将元素之e，以及它的前后指针维护到创建的指针对象中，然后与前后指针连接，就

相当于握手，集合中元素数量size自增，将指针元素返回。过程很简单，没有涉及到移动数据，只是将新增的元素与前后

元素握手就可以了，所以效率高于ArrayList。

再来看一看删除操作：

 public E remove(int index) {
        return remove(entry(index));
    }

remove(int index)有个重载的方法入参为指针Entry，方法如下：

private E remove(Entry<E> e) {
    if (e == header)
        throw new NoSuchElementException();

        E result = e.element;
    e.previous.next = e.next;
    e.next.previous = e.previous;
        e.next = e.previous = null;
        e.element = null;
    size--;
    modCount++;
        return result;
    }

首先暂存要删除的元素，然后将元素的后一个指针与前一个指针握手，再将该指针维护的前后位置元素置空，

然后返回要删除的元素，完成操作，过程没有涉及数据的移动，所以效率高于ArrayList。