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。

完结~~~