Java List源码研究

List源码研究

一、概述

ArrayList：【数组实现的】方法不同步、线程不安全、性能相对高，查找速度快,默认扩充为原来的1.5倍。

Vector：【数组实现的】方法同步（sychronized）、线程安全、性能相对低、查找速度快，可设置增长因子，一般扩充2倍。

LinkedList：【双向列表实现的】线程不安全、插入效率高。>>只在末端增删元素，用于保持数据插入的顺序。

二、ArrayList

1、继承了AbstractList，实现了RandomAccess, Cloneable, java.io.Serializable接口。

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

2、初始容量为10.

private static final int DEFAULT_CAPACITY = 10;

3、ArrayList扩容机制 ：调用ensureCapacity(int minCapacity)函数，传入扩容参数，如果扩容参数大于默认容量，就调用ensureExplicitCapacity，最终进入grow()函数进行扩容。

grow()函数接收一个minCapacity参数，新容量扩为旧容量的1.5倍。如果新容量大于 MAX_ARRAY_SIZE ，调用hugeCapacity，抛出OutOfMemoryError();否则开始执行Arrays.copyOf()函数，该方法内new了一个数组，调用了System.arraycopy()把旧的元素复制到新的数组中。

public void ensureCapacity(int minCapacity) {        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)            // any size if not default element table            ? 0            // larger than default for default empty table. It's already            // supposed to be at default size.            : DEFAULT_CAPACITY;        if (minCapacity > minExpand) {            ensureExplicitCapacity(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);    }

4、add方法实现：要add新元素，首先调用ensureCapacityInternal，此时的容量为原size+1，如果没有超过默认容量，就直接在数组最后插入该元素。

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

5、indexOf方法实现：可以看处Array是支持null元素的，首先是判断对象是否为null，然后用for循环进行查找。查找失败的时候返回-1.

 public int indexOf(Object o) {        if (o == null) {            for (int i = 0; i < size; i++)                if (elementData[i]==null)                    return i;        } else {            for (int i = 0; i < size; i++)                if (o.equals(elementData[i]))                    return i;        }        return -1;    }

三、Vector

1、与ArrayList一样， 继承了AbstractList，实现了RandomAccess, Cloneable, java.io.Serializable接口。

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

2、不同点：自己实现了coptInto方法，并且加上了synchronized同步，ArrayList中是直接调用的System.arraycopy，这样就不能保证复制过程中的同步。

  public synchronized void copyInto(Object[] anArray) {        System.arraycopy(elementData, 0, anArray, 0, elementCount);    }

3、扩容机制：把synchronized修饰符放在了最上面，判断是否需要扩容的函数上，而不是grow上。新容量默认是扩充为旧容量的两倍，但是如果在构造函数的时候传入了自定义的扩容参数，新容量就扩为旧容量+自定义增量的和。

public synchronized void ensureCapacity(int minCapacity) {        if (minCapacity > 0) {            modCount++;            ensureCapacityHelper(minCapacity);        }    }private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?                                         capacityIncrement : oldCapacity);        if (newCapacity - minCapacity < 0)            newCapacity = minCapacity;        if (newCapacity - MAX_ARRAY_SIZE > 0)            newCapacity = hugeCapacity(minCapacity);        elementData = Arrays.copyOf(elementData, newCapacity);    }

4、indexOf：同样也是支持null元素的，唯一不同的是加上了synchronized修饰。

 public synchronized int indexOf(Object o, int index) {        if (o == null) {            for (int i = index ; i < elementCount ; i++)                if (elementData[i]==null)                    return i;        } else {            for (int i = index ; i < elementCount ; i++)                if (o.equals(elementData[i]))                    return i;        }        return -1;    }

5、addAll方法：首先是被synchronized修饰，然后调用toArray()方法先将传入的集合放到一个对象数组中，然后获得数组的长度，判断是否需要扩容，然后再调用System.arraycopy()函数完成复制，最后更新当前的元素总数。

 public synchronized boolean addAll(Collection<? extends E> c) {        modCount++;        Object[] a = c.toArray();        int numNew = a.length;        ensureCapacityHelper(elementCount + numNew);        System.arraycopy(a, 0, elementData, elementCount, numNew);        elementCount += numNew;        return numNew != 0;    }

四、LinkedList

1、继承了AbstractSequentialList，实现了List,Deque, Cloneable和Serializable接口。 因此LinkedList既可以看成是List（列表），也可以看成是Deque（双端队列）。

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

2、内部实现：使用链表实现，每个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;        }    }

3、add方法：默认是在尾部添加元素。LinkedList中定义了一个last节点，该节点是记录当前最后一个节点last，然后把新节点赋给last，如果该节点为空，该节点就设为新的头节点first，如果不为空，就把该节点赋给l.next。

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