ArrayList和LinkedList源码阅读笔记

List 接口继承自Collection接口，并在Collection接口的基础上添加了大量的方法，使得可以在List 的中间插入和删除元素。
List 按照插入的顺序来保存元素，它常用的实现类主要有两种：ArrayList和LinkedList，其中ArrayList 擅长随机访问元素操作，但是在中间插入和存取元素时比较慢；而LinkedList在中间进行插入和删除的操作比较快，随机访问方面相对较慢。只要阅读以下这两个类的底层实现方式，就很容易理解它们各自的优势。 

ArrayList:

ArrayList 的列表对象实质是存放在一个引用型的数组内，并通过不断的改变该引用型数组的指向来改变数组的容量。

ArrayList 类内部：

private transient Object[] element；//存放列表对象的数组的引用，
private int size; //用来记录列表中实际对象的数量；
同时还引入Capacity，用来不断调整存放对象的数组的大小。

ArrayList 随机访问元素:

因为底层是通过Object类型的数组实现，所以可以直接通过数组下标来访问任何元素。

 

ArrayList中间插入和删除元素：

   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的index位置中插入元素时，包括index以后的所有元素都要向后移动一位，需要进行很多的赋值操作，所以ArrayList在中间插入和删除代价较大。

 

当向ArrayList增加元素时，必须保证数组的容量能够确保这个元素还能再加进去。这时候如果数组的size与capacity的值一样，就必须增大capacity的值，使add操作能顺利进行。ArrayList 通过下面方法实现自动改变数组大小机制：

private void ensureCapacityInternal(intminCapacity) {
        modCount++;
        // add 方法前面通常会有ensureCapacityInternal(size + 1)，当size + 1的值比数组容量的值小时，则不做任何操作，当size + 1的值比数组容量的值大时，则要扩大数组的容量。
 
        if (minCapacity - elementData.length> 0)
            grow(minCapacity);
}
 
private staticfinal int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private voidgrow(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);
       
//这步操作是关键，通过改变elementData的引用来实现数组容量的自动改变机制。
        element = Arrays.copyOf(elementData, newCapacity);
   }
   private static int hugeCapacity(intminCapacity) {
        if (minCapacity < 0) //overflow
            throw newOutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE)?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
}

通过以上代码，我们可知java自动增加ArrayList大小的思路是：向ArrayList添加对象时，原对象数目加1后如果大于数组长度，则建一个适当长度的新数组，并将原数组的内容进行拷贝，然后让element对这个新数组进行引用。原数组会自动抛弃（java垃圾回收机制会自动回收）。

 

LinkedList:

LinkedList内部定义了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;
        }
}

LinkedList 通过Node<E> first，Node<E> last两个属性用来标记该链表的首结点和尾结点。

 

LinkedList 在中间增加和删除元素：

LinkedList 找到index所在位置的结点，然后通过改变该位置结点的prev和next 的引用来进行插入和删除操作。

   

 public void add(intindex, 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 = newNode<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
}

LinkedList随机查找的操作：

  

  public E get(intindex) {
        checkElementIndex(index);
        return node(index).item;
}
   Node<E> node(int 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比size/2小，就从前往后找，如果index比size/2大，就从后往前找。虽然对查找进行了一定的优化，但是查找时间级别仍是O(n)，而ArrayList随机访问的时间是O(1)。