ArrayList源码中的两个值得注意的问题

1、“拖泥带水”的删除

测试代码：

package com.demo;
import java.util.ArrayList;
public class TestArrayList {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<String> arylist = new ArrayList<String>();
        arylist.add("aa");
        arylist.add("bb");
        arylist.add("bb");
        arylist.add("cc");
//        arylist.add("aa");
//        arylist.add("bb");
//        arylist.add("cc");
//        arylist.add("bb");
        String target = "bb";
        for (int i = 0; i < arylist.size(); i++) {
            if (arylist.get(i).equals(target)) {
                arylist.remove(i);
            }
        }
        for(String value:arylist){
            System.out.println(value);
        }
    }
}

这段代码的本意在于删除动态数组arylist中元素等于target的元素，通过遍历数组的每一项，当equals判定相等就删除之。如果数组中的所有元素唯一，不会存在任何问题，对应的元素得到正确的删除；如果数组中元素有重复，那么你可能理所当然地认为所有重复元素也应该全部被删除，因为似乎遍历到了每项元素。但实际结果有可能不是你想的样子。运行上述代码得到输出：

aa
bb
cc

有一个元素"bb"应该被删除但是未被删除。

但如果在调整一下动态数组中重复元素“bb”的位置（如注释的代码）为：{"aa","bb","cc","bb"}，其结果是两个“bb”全部被删除。

这里的重点在于remove()方法的实现。查看其源码：

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

从以上删除的处理逻辑可以看出，删除操作主要是调用了System.arraycopy()方法，在System类中该方法的定义为：

    public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

该方法的功能是将源数组src从srcPos位置开始，复制数量为length的元素到目标数组dest中，其中目标数组从destPos位置开始往后填充。

由此可知，remove方法中删除操作的处理办法是将elementData数组从index+1位置开始其后的numMoved各元素原地复制到index处。简单点说就是将index+1位置开始的元素依次往前挪动一个位置，因为index位置的元素反正要被删除，就直接覆盖它，最后在处理elementData最末尾无用的元素和更新size。

这样处理的问题在于，如果arylist中位置为i和i+1的元素重复且刚好是需要删除的元素，那么由于一轮删除之后，第二个元素占据第一个元素的位置，但是i++自增了，第二个元素被跳过了，未被遍历到，删除实际上是不完整的。实际上只要待删除元素存在相邻的情况都会出现这种“拖泥带水”不完整的删除。

remove(Object o)、fastRemove(int index)都是基于类似的实现方式。

正确的写法可以在必要的时候手动修正计数器i的值，但是这种实现实际上不是很优雅：

        for (int i = 0; i < arylist.size(); i++) {
            if (arylist.get(i).equals(target)) {
                arylist.remove(i);
                i--;
            }
        }

更好的实现是反向遍历删除：

        for (int i = arylist.size()-1; i >= 0; i--) {
            if (arylist.get(i).equals(target)) {
                arylist.remove(i);
            }
        }

2、不一样的初始化

ArrayList是基于对象数组实现的。

在版本JDK1.8中

其中几个常用的成员变量有：

默认的初始化容量：DEFAULT_CAPACITY

空的对象数组变量两个：EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA

真正存储元素的对象数组变量：elementData

大小：size

/**
     * Default initial capacity.
     */
    private static final int DEFAULT_CAPACITY = 10;
    private static final Object[] EMPTY_ELEMENTDATA = {};
    /**
     * Shared empty array instance used for default sized empty instances. We
     * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
     * first element is added.
     */
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    transient Object[] elementData; // non-private to simplify nested class access

    private int size;

源码的实现者特地用两个空的对象数组来区别有参和无参实例化，以满足不同条件下的使用。

对应的构造器如下：

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

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

因此，通过如下两种方式实例化后，对象数组实际上都是一个空数组，但是是不同的空数组。

        ArrayList<String> list = new ArrayList<String>(0);
        ArrayList<String> list1 = new ArrayList<String>();

第一种实例化得到的空数组是EMPTY_ELEMENTDATA，第二种实例化得到的空数组是DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

但是随后的第一次add元素后就会有所区别。

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

add()方法调用ensureCapacityInternal()方法。

    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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

ensureCapacityInternal()方法中特地有区别的对待了两个同为空的对象数组：

如果对象数组是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，那么第一次add元素时分配的容量直接从10起步，随后一直到size为10为止，add元素不会在调用grow()方法。

如果对象数组是EMPTY_ELEMENTDATA，那么第一次add元素时分配的容量是1，并且随后的几次add都会比较频繁的调用grow()，这样的增幅视乎太小了，但是仅限于前面几次add操作，到后面阶段于第一种方式基本保持一直的步调。

为何要在这里对如此细微的细节给予差别对待？我其实也不是很懂，但是大体上，猜测作者是想传递这样一个实现意图：

如果程序员用ArrayList<String> list = new ArrayList<String>(0);来实例化，那么他应该是很明确的需要空的动态数组而不需要存储任何元素，即使需要存储元素，也是一两个很少量的元素，不会频繁的add，因此不应该在第一次add操作时分配10的容量，很可能造成浪费。

如果程序员 ArrayList<String> list1 = new ArrayList<String>();来实例化，那么他是需要这个动态数组来存放元素的，因此应该在第一次add是为其分配合适的容量10。

完结~~~