JAVA语言：源码分析之ArrayList-职坐标

JAVA语言：源码分析之ArrayList

龚超 2018-07-25 来源：阅读 747 评论 0

摘要：本文主要向大家介绍了JAVA语言的源码分析之ArrayList，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。

本文主要向大家介绍了JAVA语言的源码分析之ArrayList，通过具体的内容向大家展示，希望对大家学习JAVA语言有所帮助。

ArrayList 是我们常用的集合类，是基于数组实现的。不同于数组的是 ArrayList 可以动态扩容。

类结构

ArrayList 是 Java 集合框架 List 接口的一个实现类。提供了一些操作数组元素的方法。

实现 List 接口同时，也实现了 RandomAccess , Cloneable , java.io.Serializable 。

ArrayList 继承与 AbstractList 。

类成员

elementData

transient Object[] elementData;

复制代码

elementData 是用于保存数据的数组，是 ArrayList 类的基础。

elementData 是被关键字 transient 修饰的。我们知道被 transient 修饰的变量，是不会参与对象序列化和发序列化操作的。而我们知道 ArrayList 实现了 java.io.Serializable ，这就表明 ArrayList 是可序列化的类，这里貌似出现了矛盾。

ArrayList 在序列化和反序列化的过程中，有两个值得关注的方法： writeObject 和 readObject ：

privatevoidwriteObject(java.io.ObjectOutputStream s)

throws java.io.IOException{

// Write out element count, and any hidden stuff

int expectedModCount = modCount;

s.defaultWriteObject();

// Write out size as capacity for behavioural compatibility with clone()

s.writeInt(size);

// Write out all elements in the proper order.

for (int i=0; i<size; i++) {

s.writeObject(elementData[i]);

}

if (modCount != expectedModCount) {

throw new ConcurrentModificationException();

}

privatevoidreadObject(java.io.ObjectInputStream s)

throws java.io.IOException, ClassNotFoundException {

elementData = EMPTY_ELEMENTDATA;

// Read in size, and any hidden stuff

s.defaultReadObject();

// Read in capacity

s.readInt(); // ignored

if (size > 0) {

// be like clone(), allocate array based upon size not capacity

ensureCapacityInternal(size);

Object[] a = elementData;

// Read in all elements in the proper order.

for (int i=0; i<size; i++) {

a[i] = s.readObject();

}

复制代码

writeObject 会将 ArrayList 中的 size 和 element 数据写入 ObjectOutputStream 。 readObject 会从 ObjectInputStream 读取 size 和 element 数据。

之所以采用这种序列化方式，是出于性能的考量。因为 ArrayList 中 elementData 数组在 add 元素的过程，容量不够时会动态扩容，这就到可能会有空间没有存储元素。采用上述序列化方式，可以保证只序列化有实际值的数组元素，从而节约时间和空间。

size

private int size;

复制代码

size 是 ArrayList 的大小。

DEFAULT_CAPACITY

/**

* Default initial capacity.

private static final int DEFAULT_CAPACITY = 10;

复制代码

ArrayList 默认容量是10。

构造函数

ArrayList 提供了2个构造函数 ArrayList(int initialCapacity) 和 ArrayList() 。

使用有参构造函数初始化 ArrayList 需要指定初始容量大小，否则采用默认值10。

add()方法

publicbooleanadd(E e){

ensureCapacityInternal(size + 1); // Increments modCount!!

elementData[size++] = e;

return true;

}

复制代码

在 add 元素之前，会调用 ensureCapacityInternal 方法，来判断当前数组是否需要扩容。

privatevoidensureCapacityInternal(intminCapacity){

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

// 如果elementData为空数组，指定elementData最少需要多少容量。

// 如果初次add，将取默认值10；

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

}

ensureExplicitCapacity(minCapacity);

}

privatevoidensureExplicitCapacity(intminCapacity){

modCount++;

// overflow-conscious code

// elementData容量不足的情况下进行扩容

if (minCapacity - elementData.length > 0)

grow(minCapacity);

}

privatevoidgrow(intminCapacity){

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

}

复制代码

从 grow 方法中可以看出， ArrayList 的 elementData 数组如遇到容量不足时，将会把新容量 newCapacity 设置为 oldCapacity + (oldCapacity >> 1) 。二进制位操作 >> 1 等同于 /2 的效果，扩容导致的 newCapacity 也就设置为原先的1.5倍。

如果新的容量大于 MAX_ARRAY_SIZE 。将会调用 hugeCapacity 将 int 的最大值赋给 newCapacity 。不过这种情况一般不会用到，很少会用到这么大的 ArrayList 。

在确保有容量的情况下，会将元素添加至 elementData 数组中。

add(int index, E element) 方法

publicvoidadd(intindex, E element){

rangeCheckForAdd(index);

ensureCapacityInternal(size + 1); // Increments modCount!!

System.arraycopy(elementData, index, elementData, index + 1,

size - index);

elementData[index] = element;

size++;

}

复制代码

带有 index 的 add 方法相对于直接 add 元素方法会略有不同。

首先会调用 rangeCheckForAdd 来检查，要添加的 index 是否存在数组越界问题；同样会调用 ensureCapacityInternal 来保证容量；调用 System.arraycopy 方法复制数组，空出 elementData[index] 的位置；赋值并增加 size ；

remove(int index) 方法

publicEremove(intindex){

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;

}

复制代码

ArryList 提供了两个删除 List 元素的方法，如上所示，就是根据 index 来删除元素。

检查 index 是否越界；取出原先值的，如果要删除的值不是数组最后一位，调用 System.arraycopy 方法将待删除的元素移动至 elementData 最后一位。将 elementData 最后一位赋值为null。

remove(Object o) 方法

publicbooleanremove(Object o){

if (o == null) {

for (int index = 0; index < size; index++)

if (elementData[index] == null) {

fastRemove(index);

return true;

}

} else {

for (int index = 0; index < size; index++)

if (o.equals(elementData[index])) {

fastRemove(index);

return true;

}

return false;

}

复制代码

remove(Object o) 是根据元素删除的，相对来说就要麻烦一点：

当元素 o 为空的时候，遍历数组删除空的元素。当元素 o 不为空的时候，遍历数组找出于 o 元素的 index ，并删除元素。如果以上两步都没有成功删除元素，返回 false 。

modCount

在 add 、 remove 过程中，经常发现会有 modCount++ 或者 modCount-- 操作。这里来看下 modCount 是个啥玩意。

modCount 变量是在 AbstractList 中定义的。

protected transient int modCount = 0;

复制代码

modCount 是一个 int 型变量，用来记录 ArrayList 结构变化的次数。

modCount 起作用的地方是在使用 iterator 的时候。 ArrayList 的 iterator 方法。

publicIteratoriterator(){

return new Itr();

}

private classItrimplementsIterator{

int cursor; // index of next element to return

int lastRet = -1; // index of last element returned; -1 if no such

int expectedModCount = modCount;

publicbooleanhasNext(){

return cursor != size;

}

@SuppressWarnings("unchecked")

publicEnext(){

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

}

publicvoidremove(){

if (lastRet < 0)

throw new IllegalStateException();

checkForComodification();

try {

ArrayList.this.remove(lastRet);

cursor = lastRet;

lastRet = -1;

expectedModCount = modCount;

} catch (IndexOutOfBoundsException ex) {

throw new ConcurrentModificationException();

}

@Override

@SuppressWarnings("unchecked")

publicvoidforEachRemaining(Consumer consumer){

Objects.requireNonNull(consumer);

final int size = ArrayList.this.size;

int i = cursor;

if (i >= size) {

return;

}

final Object[] elementData = ArrayList.this.elementData;

if (i >= elementData.length) {

throw new ConcurrentModificationException();

}

while (i != size && modCount == expectedModCount) {

consumer.accept((E) elementData[i++]);

}

// update once at end of iteration to reduce heap write traffic

cursor = i;

lastRet = i - 1;

checkForComodification();

}

finalvoidcheckForComodification(){

if (modCount != expectedModCount)

throw new ConcurrentModificationException();

}

复制代码

iterator 方法会返回私有内部类 Itr 的一个实例。这里可以看到 Itr 类中很多方法，都会调用 checkForComodification 方法。来检查 modCount 是够等于 expectedModCount 。如果发现 modCount != expectedModCount 将会抛出 ConcurrentModificationException 异常。

这里写一个小例子来验证体会下 modCount 的作用。简单介绍一下这个小例子：准备两个线程 t1 、 t2 ，两个线程对同一个 ArrayList 进行操作， t1 线程将循环向 ArrayList 中添加元素， t2 线程将把 ArrayList 元素读出来。

Test 类：

public classTest{

Listlist = new ArrayList();

publicTest(){

}

publicvoidadd(){

for (int i = 0; i < 10000; i++) {

list.add(String.valueOf(i));

}

publicvoidread(){

Iterator iterator = list.iterator();