List 源码分析

在Java中，List接口的继承结构图大概如图所示，其中最上层的Iterable接口和Collection接口是所有Java集合类都需要实现的接口，Iterable接口提供了iterator()方法，可以返回一个Iterator对象，而Iterator也是一个接口，所有实现了Iterable接口的集合类都需要重写iterator()方法，并且在集合类内部还需要实现Iterator接口的next()等方法用于迭代。

这篇文章就从源码的层面来看看这些常用的List接口的实现类

一、ArrayList

顾名思义，我们从简单的名字就可以猜到，ArrayList的底层应该是采用数组来存储的。而ArrayList与数组最大的区别就在于，数组的大小是固定的，而ArrayList可以进行动态扩容。

1.1 构造方法

ArrayList提供了三个构造方法

指定集合初始化容量，如果容量大于0就直接创建一个指定大小的数组，如果等于0，就创建一个空数组

private static final Object[] EMPTY_ELEMENTDATA = {};

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

无参构造，直接创建一个空数组

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

集合为入参，将集合的元素转成数组，如果是同类型集合，直接改变elementData的内存指向即可，如果其他类型结合，通过拷贝的方式将原数组的数据拷贝到elementData数组中；如果入参集合的元素为空，就直接创建一个空数组

public ArrayList(Collection<? extends E> c) {
    Object[] a = c.toArray();
    if ((size = a.length) != 0) {
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, size, Object[].class);
        }
    } else {
        // replace with empty array.
        elementData = EMPTY_ELEMENTDATA;
    }
}

1.2 ADD/GET/SET/REMOVE方法

集合添加元素都是通过add()方法拉完成，ArrayList的add()方法有两种：

第二种add()方法可以指定下标位置，将数据添加进去，由于ArrayList是采用数组存储的，由于数组空间的连续性，如果指定下标添加元素，需要把当前下标以后的元素都往后移动一位，而ArrayList移动的方式是通过System的arraycopy()方法，直接把从index开始的数据，全部拷贝到从index+1开始，然后把当前添加的值放在index位置。

而不指定元素添加的位置时，会直接把元素添加在最后的位置

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

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

在调用get()方法获取时，首先会去判断一下当前指定的下标索引是否超过了集合中元素的个数，**注意这里判断的是元素的个数，而不是数组的容量，**大于或等于元素的个数(index从0开始)，都会导致IndexOutOfBoundsException异常

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

    return elementData(index);
}

与put()方法相比，set()方法就很简单了，直接在元素防止到指定位置，可以覆盖已有数据

public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

可以直接指定某个index位置来移除元素，而移除的方式是通过拷贝把从index+1位置开始的元素全部拷贝到从index开始的位置，最后把原来数组最后一个位置的元素置为null，方便进行GC

这里面需要注意modCount属性，这个属性在移除操作时进行了+1，后面会分析这个属性是干嘛的

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

1.3 扩容

在前面两个add()方法中，它们在添加元素前，都会去调用ensureCapacityInternal()，而这个方法就是去判断是否需要扩容以及进行扩容

首先会去调用calculateCapacity()来计算需要的容量大小，如果此时的elementData是一个空数组(构造时没有指定容量大小)，就会从默认容量和需要的最小容量中选一个最大值作为数组的容量；如果数组不是一个空数组，那么就直接返回需要的最小容量

private static final int DEFAULT_CAPACITY = 10;

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

在ensureExplicitCapacity()方法里面，也会对modCount属性进行+1操作

如果当前需要的最小容量比当前的数组容量要大，则调用grow()方法进行扩容

扩容的方式也很简单，直接在原来容量大小的基础上，扩大0.5倍，扩容的方式也很简单，直接使用System的arraycopy()方法将原来数组的数据直接拷贝到新数组上，这是一种典型的用空间换时间的做法

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

注：在remove()方法和add()方法中的ensureExplicitCapacity()方法，都会对modCount属性进行+1，而get()方法中并没有，我们可以把modCount理解为记录了操作ArrayList的次数

1.4 迭代

ArrayList实现了Iterable接口，自然要实现iterator()方法，该方法直接返回了一个Itr对象，这是ArrayList的内部类

public Iterator<E> iterator() {
    return new Itr();
}

下面我们看一下Itr的实现，它实现了Iterator接口，自然要实现其next()和remove()方法

需要注意的时，在Itr中，用expectedModCount记录了当前ArrayList中对元素操作的记录数

而在Itr的next()方法中，首先会去调用checkForComodification()方法，这个方法就是判断expectedModCount和modCount是否相等的。

这就是为什么，我们在使用Iterator来遍历集合时，不能通过集合对象来执行add()或remove()方法，执行这两个方法后，modCount的值就会+1，导致与expectedModCount不相等，就会导致ConcurrentModificationException异常

但可以调用Itr的remove()方法，这个方法里面不会检查expectedModCount和modCount，并会对expectedModCount重赋值

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    Itr() {}

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

如果需要在遍历时调用add()方法，可以通过listIterator()方法来得到一个ListItr对象，这个类也是ArrayList的内部内，其实现了ListIterator接口，它的add()方法也会对expectedModCount重新赋值，就不会抛出异常

private class ListItr extends Itr implements ListIterator<E> {
    ListItr(int index) {
        super();
        cursor = index;
    }
    ……
    public void add(E e) {
        checkForComodification();

        try {
            int i = cursor;
            ArrayList.this.add(i, e);
            cursor = i + 1;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }
}

二、LinkedList

2.1 存储结构

LinkedList采用的是双向链表的结构，在LinkedList中是以Node为单位进行存储的，Node的结构如下：

Node中包含了节点的元素item，以及分别指向前后两个节点的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实现了Deque接口的所有方法，并且通过first和last来记录链表的起始节点和尾部节点

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    transient int size = 0;

    transient Node<E> first;

    transient Node<E> last;

    // Constructs an empty list.
    public LinkedList() {
    }
}

2.2 常用方法

Deque接口中，定义很多addFirst()、offerFirst()、removeFirst()、pollFirst()、getFirst()、peekFirst()以及的xxxLast()方法，这些方法都在LinkedList实现了，但这些方法内部都会调用同样的方法

• add(E e)

  add()方法就很简单，直接在链表最后插入一个节点即可

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

• get(int index)

  首先也是会检查索引是否小于0，或者大于等于元素个数，node()方法的实现也很简单，首先会判断索引index位置靠近头结点还是尾节点，然后往前后往后遍历

  public E get(int index) {
      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;
      }
  }
  

• remove()

  remove()方法可以根据元素位置或内容进行移除，都是先找到对应的Node节点，然后调用unlink()方法来调整Node节点前后节点的指向来删除Node节点

  public E remove(int index) {
      checkElementIndex(index);
      return unlink(node(index));
  }
  
  public boolean remove(Object o) {
      if (o == null) {
          for (Node<E> x = first; x != null; x = x.next) {
              if (x.item == null) {
                  unlink(x);
                  return true;
              }
          }
      } else {
          for (Node<E> x = first; x != null; x = x.next) {
              if (o.equals(x.item)) {
                  unlink(x);
                  return true;
              }
          }
      }
      return false;
  }
  
  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;
  }
  

那么xxxFirst()和xxxLast()方法也比较简单，就不细看了

三、Vector

3.1 构造方法

与ArrayList相比，Vector也是采用数组进行存储，但不同的是，在创建Vector对象时，如果没有为数组指定大小，Vector会指定默认值为10，直接在构造时就创建一个大小为10的数组。

protected Object[] elementData;
protected int capacityIncrement;

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
    this.capacityIncrement = capacityIncrement;
}

public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

public Vector() {
    this(10);
}

3.2 指定扩容

在扩容方面，Vector与ArrayList也有不同，在创建Vector实例时，不仅可以指定初始数组的容量大小，还可以指定每次扩容的大小，capacityIncrement属性用来记录这个扩容大小，如果capacityIncrement大于0，每次就扩容capacityIncrement的大小；否则就直接将数组容量扩大至原来的2倍

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

3.3 方法同步

与ArrayList相比，Vector最大的区别在于它是一个线程安全的集合，它的线程安全是通过synchronized关键字来保证的，Vector中的所有方法，都加了synchronized关键字

它的add()、get()、set()、remove()等方法与ArrayList相比，在具体实现上没什么区别，主要就是通过synchronized关键字保证了方法同步，synchronized作用在方法上，是对同一个Vector对象调用所有方法进行同步阻塞

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

public synchronized E get(int index) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    return elementData(index);
}

public synchronized E set(int index, E element) {
    if (index >= elementCount)
        throw new ArrayIndexOutOfBoundsException(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

public boolean remove(Object o) {
    return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
    modCount++;
    int i = indexOf(obj);
    if (i >= 0) {
        removeElementAt(i);
        return true;
    }
    return false;
}