java8 ArrayList源码阅读【2】- 总结

上一篇文章 java8 ArrayList源码阅读已经分析了ArrayList源码，现对ArrayList做个小结。

ArrayList一个动态数组,其本质也是用数组实现的，它具有：随机访问速度快，插入和移除性能较差(数组的特点)；支持null元素；有顺序；元素可以重复；线程不安全；

ArrayList实现了List接口以及list相关的所有方法，它允许所有元素的插入，包括null。另外，ArrayList和Vector除了线程不同步之外，大致相等。

ArrayList继承AbstractList并实现了List接口，RandomAccess接口，Cloneable接口，Serializable接口，因此它支持快速访问，可复制，可序列化。

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

ArrayList 默认初始化大小为0（不是10）

//在以前的版本，ArrayList 默认初始化大小为10，其默认构造函数为
public ArrayList() {
this(10);
}

//jdk8版本，默认构造方法，使用空数组初始化，容量大小默认为0
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA; //EMPTY_ELEMENTDATA={}
}

ArrayList内部数组的扩容：

当向ArrayList添加新元素前，会调用ensureCapacityInternal(int)方法来保证内部数组空间足够。

//添加新元素时使用，使用指定参数设定最小容量，minCapacity为size+1
private void ensureCapacityInternal(int minCapacity) {
//如果数组为空，使用默认值和参数中较大者作为容量预设值
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}

//根据指定参数增加数组容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++; //上面提到，只要涉及数组结构的改变(这里是数组大小改变)，该变量改变

//如果参数大于数组容量，就增加数组容量
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

//增加容量，以确保它可以至少持有由参数指定的元素的数目
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;

//新容量为原来的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);

//如果仍比参数小，则新容量大小取参数的值
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//若新容量大于默认的最大值，则检查是否溢出
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);

elementData = Arrays.copyOf(elementData, newCapacity);
}

从grow()方法可以看出，如果内部数组空间不够，ArrayList每次扩容都是扩1.5倍，然后调用Arrays类的copyOf方法，把元素重新拷贝到一个新的数组中去。扩1.5倍的原因也好理解，因为扩容本质最后是将元素全部重新拷贝到一个新的数组，是耗时的，所以如果每次add都需要扩容一次，那效率是非常低的。所以预存一定空间以供add使用。

ArrayList内部数组的收缩：

利用trimToSize()方法，由于数组扩容时是扩大1.5倍，因此通常会出现容量大于实际有效元素数量，可以将数组占用内存大小压缩到数组中元素个数，可以在内存紧张时调用。同样也是通过Arrays.copyof方法将元素拷贝到一片新的内寸空间，老的空间由gc回收。

//释放数组空余的空间，容量为数组实际元素数量（因为容量通常会大于实际元素数量，
public void trimToSize() {
modCount++;     //涉及数组的改变，modCount都会改变，留意该变量，后面会频繁出现
if (size < elementData.length) {    //如果数组实际元素数量比数组容量小，则重新拷贝到一片新的内寸空间
elementData = Arrays.copyOf(elementData, size);
}
}

indexOf(Object o)

该方法会根据是否为null使用不同方式判断。如果是元素为null，则直接比较地址，否则使用equals的方法比较，加快比较效率。lastIndexOf(Object o) 同理。

//返回特定元素在数组首次出现的位置（遍历的方式），会根据是否为null使用不同方式判断。不存在就返回-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;  //不存在返回-1
}

clone() 浅拷贝

//返回副本，浅拷贝
//复制过程数组发生改变会抛出异常
public Object clone() {
try {
//java.lang.Object.clone()只是一种浅复制，所以，v的elementData引用的还是当前ArrayList的elementData的引用
java.util.ArrayList<?> v = (java.util.ArrayList<?>) super.clone();
//对原来ArrayList的elementData进行一个数组拷贝，然后赋值给v的elementData
//这样，v的elementData就是原先ArrayList的elementData的一个副本，不再是内存中同一块数组
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}

举个例子说明：

public class Main {
static class A {
int a;

A(int a) {
this.a = a;
}

@Override
public String toString() {
return super.toString() + " : " + a;
}
}

public static void main(String[] args) {
ArrayList<A> a1=new ArrayList<>();
a1.add(new A(1));
a1.add(new A(2));
ArrayList<A> a2= (ArrayList<A>) a1.clone();
System.out.println(a1);
System.out.println("---");
System.out.println(a1);
System.out.println("---");
a2.get(1).a=100;
System.out.println(a1);
System.out.println("---");
System.out.println(a1);
System.out.println("---");
}
}
/*
* 输出结果：
[Main$A@1b6d3586 : 1, Main$A@4554617c : 2]
---
[Main$A@1b6d3586 : 1, Main$A@4554617c : 2]
---
[Main$A@1b6d3586 : 1, Main$A@4554617c : 100]
---
[Main$A@1b6d3586 : 1, Main$A@4554617c : 100]
---
*/

从上述输出结果可以看出，尽管克隆的数组不是跟原数组同一块内存，但内容引用是同样的，指向同一个地址，可以从输出结果看出，因此改变克隆后数组的元素内容，相应的原数组内容发生相应变化，因此clone()方法是浅拷贝。

（注：对于基本类型，如int，则不会发生这种情况。）

add(),addAll(),remove(),removeRange()

关于对数组元素的添加或删除，其实现均是用System.arraycopy()来移动的。

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

removeAll 和 retainAll

removeAll 是删除指定集合的元素，retainAll则是仅保留指定集合的元素。

//部分应用场景：
//并集
list1.addAll(list2);
//交集
list1.retainAll(list2);
//差集
list1.removeAll(list2);
//无重复并集
list2.removeAll(list1);
list1.addAll(list2);

而它们背后的实现则比较巧妙。

//删除指定集合的元素
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);  //检查集合是否为空
return batchRemove(c, false);   //调用batchRemove，complement为false
}

//与removeAll相反，仅保留指定集合的元素
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);  //检查集合是否为空
return batchRemove(c, true);    //调用batchRemove，complement为true
}

//complement true时从数组保留指定集合中元素的值，为false时从数组删除指定集合中元素的值。
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;   //w为数组更新后的大小
boolean modified = false;
try {
//遍历数组，并检查元素是否在指定集合中，根据complement的值保留特定值到数组
//若complement为true即保留，则将相同元素移动到数组前端
//若complement为false即删除，则将不同元素移动到数组前端
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
//如果r!=size则说明c.contains(elementData[r])抛出异常
if (r != size) {
//将数组未遍历的部分添加
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
//如果w!=size说明进行了删除操作，故需将删除的值赋为null
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;   //更新数组容量
modified = true;
}
}
return modified;
}

可以看出它们的实现类似于jvm中垃圾回收机制中的整理-清除方法，即先将需要保留的元素紧凑地移到一块儿，剩下的即为可以删除的元素，然后剩下的元素置null。

modCount变量[fail-fast机制]

记录了数组的修改次数，在ArrayList的所有涉及结构变化的方法中都增加modCount的值，包括：add()、remove()、addAll()、removeRange()及clear()方法。这些方法每调用一次，modCount的值就加1。

该变量迭代器等方面体现。

//返回普通迭代器
public Iterator<E> iterator() {
return new java.util.ArrayList.Itr();
}

java.util.ArrayList.Itr()是ArrayList的一个内部类，其包含了一个int型的属性：expectedModCount，这个属性在Itr类初始化时被赋予ArrayList对象的modCount属性的值。该内部类的每个方法都涉及到checkForComodification()方法。

//检查数组是否修改，根据expectedModCount和modCount判断
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}

因此在使用迭代器迭代过程中，不允许对数组结构做修改，否则会抛出异常 java.util.ConcurrentModificationException。

举例如下：

public class Main {
static class A {
int a;

A(int a) {
this.a = a;
}

@Override
public String toString() {
return super.toString() + " : " + a;
}
}

public static void main(String[] args) {
ArrayList<A> a1=new ArrayList<>();
a1.add(new A(1));
a1.add(new A(2));
Iterator i=a1.iterator();
System.out.println(i.next()+"");
a1.get(1).a=100;    //ok
a1.add(new A(3));   //error
System.out.println(i.next()+"");
}
}
/*
* 输出为：
Main$A@1b6d3586 : 1
Exception in thread "main" java.util.ConcurrentModificationException
*/

forEach() java8新增方法

//遍历每个元素做指定操作，java8新增方法
@Override
public void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);  //检查action是否为空
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int size = this.size;
for (int i = 0; modCount == expectedModCount && i < size; i++) {
action.accept(elementData[i]);
}
//检查数组结构是否修改
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}

java8前，遍历集合通常使用for循环来遍历，比如遍历输出：

for(A a:aList){
System.out.println(a);
}

现在可以采用

// lambda
aList.foreach(a -> System.out.println(a);
// or
aList.forEach(new Consumer<A>() {
@Override
public void accept(A a) {
System.out.println(a);
}
});

spliterator() java8新增方法

类似Iiterator，用于多线程，仍需学习。

removeIf() java8新增方法

其实现有点类似batchRemove()的实现方式，先将需要保留的元素紧凑地移到一块儿，剩下的即为可以删除的元素。同时还利用了BitSet来记录要删除元素的下标。

//判断条件是否满足，满足则删除，java8新增方法
@Override
public boolean removeIf(Predicate<? super E> filter) {
Objects.requireNonNull(filter);     //检查filter是否为空
int removeCount = 0;    //记录要删除的数目
final BitSet removeSet = new BitSet(size);  //利用BitSet来记录删除元素的下标
final int expectedModCount = modCount;
final int size = this.size;
for (int i = 0; modCount == expectedModCount && i < size; i++) {
@SuppressWarnings("unchecked")
final E element = (E) elementData[i];
//如果当前元素符合条件，则BitSet标记当前下标
if (filter.test(element)) {
removeSet.set(i);
removeCount++;
}
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}

final boolean anyToRemove = removeCount > 0;    //根据removeCount变量判断是否有满足条件的元素
if (anyToRemove) {
final int newSize = size - removeCount; //删除后数组元素的个数
//遍历数组，将不满足的元素前移到数组前端
for (int i = 0, j = 0; (i < size) && (j < newSize); i++, j++) {
i = removeSet.nextClearBit(i);
elementData[j] = elementData[i];
}
//将更新后的数组没用的元素置null
for (int k = newSize; k < size; k++) {
elementData[k] = null;  // Let gc do its work
}
this.size = newSize;
//检查数组是否修改
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}

return anyToRemove;
}

replaceAll() java8新增方法

//根据operator进行替换，java8新增方法
@Override
@SuppressWarnings("unchecked")
public void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final int expectedModCount = modCount;
final int size = this.size;
for (int i = 0; modCount == expectedModCount && i < size; i++) {
elementData[i] = operator.apply((E) elementData[i]);
}
//检查数组是否修改
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}

sort() java8新增方法

//根据Comparator排序，java8新增方法
@Override
@SuppressWarnings("unchecked")
public void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, size, c);
//检查数组是否修改
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}

java8之前，集合排序要用Collections.sort()方法，现在可以直接用自带的sort方法了。

// lambda
aList.sort((a,b)->(a.a-b.b));
// or
a1.sort(new Comparator<A>() {
@Override
public int compare(A o1, A o2) {
return o1.a-o2.a;
}
});