一、 类与成员变量：
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList继承自AbstractList抽象类，实现了List<E>、RandomAccess、Cloneable、Serializable接口。
其中：
实现RandomAccess接口的List可以通过简单的for循环来访问数据比使用iterator访问来的高效快速。
实现Cloneable接口的类的对象允许被克隆。同时该类需要重写Object类的clone方法。
实现Serializable接口，即采用了Java默认的序列化机制。
private static final long serialVersionUID = 8683452581122892189L;
serialVersionUID 是源类的哈希值。有了serialVersionUID之后，那么如果序列化的类已经保存了在本地中，中途你更改了类后，serialVersionUID变了，那么反序列化的时候就不会变成原始的类了，还会抛异常，主要就是用于版本控制。
*序列化的作用是能转化成Byte流，然后又能反序列化成原始的类。能在网络进行传输，也可以保存在磁盘中。
private transient Object[] elementData; private int size;
transient关键字的作用：在采用Java默认的序列化机制的时候，被该关键字修饰的属性不会被序列化。但是Object[] elementData属性是ArrayList的底层数据结构，在网络传输中一定需要将其序列化，之后使用的时候还需要反序列化，那不采用Java默认的序列化机制，那采用什么呢？直接翻到源码的最下边有两个方法，发现ArrayList自己实现了序列化和反序列化的方法writeObject()、readObject()。
writeObject()、readObject()的源码：
/** * 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(); }
二、构造：
public ArrayList(int initialCapacity) { //父类的构造器，调用子类构造时必须先调用父类构造，通常为隐式调用。若父类没有无 参构造，则必须显示调用。 super(); if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; } public ArrayList() { this(10); } public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); size = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); }
当我们执行 new ArrayList<String>()时，会调用无参构造，实际是调用ArrayList(int initialCapacity)创建了一个容量为10的对象。
当我们执行 new ArrayList<String>(2)时，会调用ArrayList(int initialCapacity)，创建了一个容量为2的对象。
**在实际使用中，如果可以估算出所需的大小，建议调用ArrayList(int initialCapacity)构造，如估计需要放置18个元素到容器，就可以new ArrayList<String>(20)，这样会减少数组扩容时引起的效率下降。
当我们执行 new ArrayList<String>(Collection c)时，实际是将其他Collection容器转为ArrayList对象。
三、操作ArrayList
1、添加
public boolean add(E e) { ensureCapacity(size + 1); // Increments modCount!! elementData[size++] = e; return true; } public void ensureCapacity(int minCapacity) { modCount++; int oldCapacity = elementData.length; if (minCapacity > oldCapacity) { Object oldData[] = elementData; int newCapacity = (oldCapacity * 3)/2 + 1; if (newCapacity < minCapacity) newCapacity = minCapacity; // minCapacity is usually close to size, so this is a win: elementData = Arrays.copyOf(elementData, newCapacity); } }
