Java Collections - ArrayList

ArrayList

ArrayList内部使用动态数组的形式来保存数据，每次添加元素的时候，会插入到数组尾部。数组大小不够时，会扩容。
与ArrayList相关的还有一个LinkedList，内部用链表来存储数据。

初始化

初始化一个ArrayList的方法如下：

    ArrayList<Integer> numbers = new ArrayList<>();

如果不指定大小，默认的数组大小是10。

这个类里面定义了几个成员变量

    /**
    * Default initial capacity.
    * 数组的默认大小
    */
    private static final int DEFAULT_CAPACITY = 10;
  /**
     * Shared empty array instance used for empty instances.
     * 数组里没有元素时的空数组
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
     * DEFAULT_CAPACITY when the first element is added.
     * 存储数据的地方，如果调用无参构造函数，开始时指向EMPTY_ELEMENTDATA，添加元素，大小就会扩展到10；如果调用有参构造参数，就会指向一个初始化大小的数据。
     */
    private transient Object[] elementData;

    /**
     * The size of the ArrayList (the number of elements it contains).
     * 数组里真实存储的元素个数
     * @serial
     */
    private int size;

    //记录了ArrayList被修改的次数，在高并发的时候，子类可以通过这个参数来判断普通数组时，是不是被其他线程修改了，抛出ConcurrentModificationException。没有深入研究
    protected transient int modCount = 0;

添加元素

用add方法往里面添加元素，会加在数据的最尾部。

    numbers.add(10);
    numbers.add(100);
    numbers.add(150);

在添加元素之前，会先判断数据的空间是否充足。

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

ensureCapacityInternal方法会保证数据的大小。

private void ensureCapacityInternal(int minCapacity) {
//EMPTY_ELEMENTDATA是一个空数组，当ArrayList里没有元素时，elementData指向空数组，这个可以不占用空间。
//取默认大小和minCapacity中较大的那个，默认大小是10
   if (elementData == EMPTY_ELEMENTDATA) {
       minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
   }
        //保证数组的大小
   ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
   modCount++;

   // overflow-conscious code
   //如果当前elementData的大小比需要的最小容量还小，就要调用grow方法来扩充容量。
   if (minCapacity - elementData.length > 0)
       grow(minCapacity);
}

grow方法用来扩容，扩大到原始大小的2.5倍。使用了位移的方法来加快运算速度。

private void grow(int minCapacity) {
   // overflow-conscious code
   int oldCapacity = elementData.length;
   //原始容量的2.5倍
   int newCapacity = oldCapacity + (oldCapacity >> 1);
   if (newCapacity - minCapacity < 0)
       newCapacity = minCapacity;   //取最小容量
   //如果超过了最大容量(Integer.MAX_VALUE - 8)，就使用Integer.MAX_VALUE
   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);
}

在使用ArrayList的时候，最好估算好大小，分配合适的空间。否则在扩容的时候会频繁的拷贝数据，影响性能。

遍历元素

遍历的方法有两种。使用index遍历和for each遍历。

    System.out.println("#1: indexed loop for iteration");
    for (int i = 0; i < numbers.size(); i++) {
      System.out.println(numbers.get(i));
    }

    System.out.println("2#: iteration");
    for (Integer value : numbers) {
      System.out.println(value);
    }

它们的性能如何呢？对于ArrayList，index遍历的性能要更优，但是也优不了多少。
在Java里，foreach语法是iterator的变形

for(int i : weights) {
    sum += i;
}

等同与：

for(Iterator<Integer> i = weights.iterator(); i.hasNext()) {
    sum += i.next();
}

删除元素

在ArrayList删除元素的耗时与位置有关。
删除最后一个元素：直接把数组的大小减1就行。
删除中间某个元素：需要将它后面的部分都拷贝一次，开销比较大。
因此尽量不要在ArrayList上频繁删除元素。