ArrayList是数组元素常用的数据结构，比较简单。

主要从以下几点总结以下该结构。

ArrayList的基本属性：

//对象数组：ArrayList的底层数据结构，用于存放数据，

private transient Object[] elementData;

//elementData中已存放的元素的个数，注意：不是elementData的容量

private int size;

是不是对transient的使用有点迷糊？下面讲到

ArrayList的内容序列化

transient关键字的作用：在采用Java默认的序列化机制的时候，被该关键字修饰的属性不会被序列化。

ArrayList类实现了java.io.Serializable接口，即采用了Java默认的序列化机制

上面的elementData属性采用了transient来修饰，表明其不使用Java默认的序列化机制来实例化，但是该属性是ArrayList的底层数据结构，在网络传输中一定需要将其序列化，之后使用的时候还需要反序列化，那不采用Java默认的序列化机制，那采用什么呢序列化方式呢？

源码有两个方法，ArrayList自己实现了序列化和反序列化

/**

* Save the state of the <tt>ArrayList</tt> instance to a stream (that is,

* serialize it).

*

* @serialData The length of the array backing the <tt>ArrayList</tt>

* instance is emitted (int), followed by all of its elements

* (each an <tt>Object</tt>) in the proper order.

*/

private void writeObject(java.io.ObjectOutputStream s)

throws java.io.IOException {

// Write out element count, and any hidden stuff

int expectedModCount = modCount;

s.defaultWriteObject();

// Write out array length

s.writeInt(elementData.length);

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

}

}

/**

* Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,

* deserialize it).

*/

private void readObject(java.io.ObjectInputStream s)

throws java.io.IOException, ClassNotFoundException {

// Read in size, and any hidden stuff

s.defaultReadObject();

// Read in array length and allocate array

int arrayLength = s.readInt();

Object[] a = elementData = new Object[arrayLength];

// Read in all elements in the proper order.

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

a[i] = s.readObject();

}

ArrayList的构造器：

/**

* 创建一个对象数组，容量为initialCapacity，

*/

public ArrayList(int initialCapacity) {

super();

AbstractList() {}

if (initialCapacity < 0)

throw new IllegalArgumentException("Illegal Capacity:" + initialCapacity);

this.elementData = new Object[initialCapacity];

}

/**

* 默认初始化一个容量为10的对象数组

*/

public ArrayList() {

this(10);

}

当执行new ArrayList<String>()时，会调用上边的无参构造器，创造一个容量为10的对象数组。

在我们执行new ArrayList<String>(4)时，会调用上边的public ArrayList(int initialCapacity)，创造一个容量为4的对象数组。

在实际使用中，如果是成员变量可以确定的场景，建议直接初始化时定好容量。

ArrayList扩容

/**

* 确保数组的容量足够，若是不够，必须扩容

*/

public void ensureCapacity(int minCapacity) {

modCount++;

int oldCapacity = elementData.length;//获取数组的容量

//容量满的情况下

if (minCapacity > oldCapacity) {

Object oldData[] = elementData;

int newCapacity = (oldCapacity * 3) / 2 + 1;//新容量为旧容量的1.5倍+1

if (newCapacity < minCapacity)//如果扩容后的新容量还不满足新增要求

newCapacity = minCapacity;//新容量设为预期需要的容量

elementData = Arrays.copyOf(elementData, newCapacity);//复制元素并使用新的容量大小

}

}

在上述代码的扩容结束后，调用了Arrays.copyOf(elementData, newCapacity)方法，这个方法先创建了一个新的容量为newCapacity的对象数组，然后使用System.arraycopy()方法将旧的对象数组复制到新的对象数组中去了。

注意：

modCount变量用于在遍历集合（iterator()）时，检测是否发生了add、remove操作。

删除ArrayList中的对象

remove(Object o)需要遍历数组，remove(int index)不需要，只需要判断索引符合范围即可，所以，通常：后者效率更高。

遍历ArrayList中的对象（iterator方式）

源代码：iterator()方法是在内部类AbstractList中实现的，该方法返回AbstractList的一个内部类Itr对象

public Iterator<E> iterator() {

return new Itr();//返回一个内部类对象

}

Itr内部类:

private class Itr implements Iterator<E> {

int cursor = 0;//标记遍历到的元素位置

int expectedModCount = modCount;

//ArrayList修改次数，用于fast fail机制快速失败 原理详见HashMap篇

//检测对象数组是否还有元素

public boolean hasNext() {

return cursor != size();//如果cursor==size，表示遍历结束

}

//获取下一元素

public E next() {

checkForComodification();//检测在遍历的过程中，ArrayList是否发生了内容变化

try {

E next = get(cursor++);

return next;

} catch (IndexOutOfBoundsException e) {

checkForComodification();

throw new NoSuchElementException();

}

}

//检测在遍历的过程中，是否发生内容变化

final void checkForComodification() {

if (modCount != expectedModCount)//预期修改次数是否等于真的修改次数

throw new ConcurrentModificationException();

}

}

ArrayList基于数组方式实现，容量限制几乎无限

ArrayList线程不安全