ArrayList源码解析
1.父类与接口
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList继承了AbstractList类，同时实现了List(list规范)、RandomAccess、Cloneable(克隆)、Serializable(序列号)接口
2.类的属性
/** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10; /** * Shared empty array instance used for empty instances. */ 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 = {}; /** * The array buffer into which the elements of the ArrayList are stored. * The capacity of the ArrayList is the length of this array buffer. Any * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA * will be expanded to DEFAULT_CAPACITY when the first element is added. */ transient Object[] elementData; // non-private to simplify nested class access /** * The size of the ArrayList (the number of elements it contains). * * @serial */ private int size;
ArrayList一共定义了五个属性，其中三个为final static，即这三个属性为ArrayList所有对象所共享，且不能被修改
int DEFAULT_CAPACITY = 10;//ArrayList初始化容量
Object[] EMPTY_ELEMENTDATA = {};//实例共享的空集合
Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//以默认大小初始化的共享的空集合。
剩余的两个属性
transient Object[] elementData;//实际存储对象的集合，使用了transient，使该属性不会被序列化。由此可见，ArrayList采用数组的形式存储元素。
private int size;//集合的实际元素数量
3.类的构造函数
public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }
public ArrayList()：无参构造器，元素为共享的空数组。
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); } }
public ArrayList(int initialCapacity)：参数为int类型的构造函数。指定集合的初始容量，如果参数大于0，则建立与之对应的新的数组，如果参数等于0，则等于共享的空数组。由于此时仍未添加元素，因此size值未被操作，仍旧是0。
public ArrayList(Collection<? extends E> c) { elementData = c.toArray();// ArrayList采用Arrays.copyof(elementData,size) if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. this.elementData = EMPTY_ELEMENTDATA; } }
public ArrayList(Collection<? extends E> c)：参数为集合的构造函数。如果参数为空集合，则用共享的空数组作为集合的数组。否则，调用参数的toArray()方法，将参数中的元素赋值给elementData(在这个过程中，赋值给elementData的是一个新的数组，对参数中的元素进行操作，不会再影响该集合的元素，具体在toArray()方法中说明)，同时判断参数的类类型是否为Objec[]，如果不是，将其转换为Object[]数组，并将元素添加进去。
4.ArrayList元素添加、删除和查询
添加元素
public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; } 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); } private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
步骤1：调用boolean add(E e)方法添加元素。
步骤2：判断用以存储元素的数组elementData是否等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA(共享的空数组)，如果是，说明该集合中elementData尚未初始化，此时size=0，elementData={}，因此最小容量minCapacity应为默认的初始化容量。如果不等于，说明elementData已经被初始化，minCapacity应为当前元素数量加1，即size+1。
步骤3：当minCapacity比elementData的length大，说明该数组已经无法存储更多的元素，需要进行扩容，进入grow(int m)。否则，直接将新增的元素添加到elementData中，并return true。
步骤4：当元素elementData需要扩容时候，每次都会扩容1.5倍。考虑到存在溢出问题，分为三种情况讨论：
(1)newCapacity小于MAX_ARRAY_SIZE。
此时正常扩容1.5倍。
(2)newCapacity大于MAX_ARRAY_SIZE，小于Integer.MAX_VALUE。
此时进入hugeCapacity方法，如果minCapacity小于0，抛出异常OutOfMemoryError。如果大于MAX_ARRAY_SIZE，只能返回Integer.MAX_VALUE(讲道理，这里也已经超出了数组允许的最大值，应该也会抛出异常OutOfMemoryError)。如果minCapacity小于MAX_ARRAY_SIZE，则返回MAX_ARRAY_SIZE，下次扩容时，抛出异常OutOfMemoryError。
(3)newCapacity大于Integer.MAX_VALUE。
这种情况下，在初始化newCapacity时内存溢出，newCapacity变为负数，newCapacity=minCapacity。
步骤5：最后将新元素添加在elementData[size+1]的位置，返回true。
删除元素：
根据索引删除元素
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; } private void rangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
使用Native方法System.arraycopy对index之后的数据进行重新复制，令原本最后位的数据=null，最后返回被移除的数据。
根据原对象删除元素：
public boolean remove(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; } private void fastRemove(int index) { modCount++; 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 }
步骤1：for循环遍历集合内元素数组，如果找到该对象，使用Native方法System.arraycopy对index之后的数据进行覆盖，然后令--size位的数据=null，并返回true。如果没有找到该对象，返回false。
部分常用方法：
public int size() { return size; }
int size()：返回当前集合中size的值。
public boolean isEmpty() { return size == 0; }
boolean isEmpty()：判断当前集合元素是否为空，判断标准size是否等于0。
