源码分析二(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。