类图
- 实现了RandomAccess接口，可以随机访问
- 实现了Cloneable接口，可以克隆
- 实现了Serializable接口，可以序列化、反序列化
- 实现了List接口，是List的实现类之一
- 实现了Collection接口，是Java Collections Framework成员之一
- 实现了Iterable接口，可以使用for-each迭代
属性
private static final long serialVersionUID = 8683452581122892189L;
private static final int DEFAULT_CAPACITY = 10;
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData;
private int size;
构造方法
1.带初始容量的构造方法
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);
}
}
- 如果初始容量大于0，就创建一个容量为初始容量的Object数组，并将数组的引用赋值给elementData；如果初始容量等于0，就将EMPTY_ELEMENTDATA赋值给elementData；否则，抛出IllegalArgumentException。
2.无参构造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
- 虽然ArrayList的无参构造器默认初始容量是10，不过它并没有创建数组，只是将elemetnData赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，等到添加第一个元素的时候，再创建数组。
3.带一个集合参数的构造方法
/**
* 创建一个集合包含集合参数的元素
*
* @param c 集合中的元素会被放到List中
* @throws NullPointerException 如果参数 c 是null,抛出NullPointerException
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray()
if ((size = elementData.length) != 0) {
// c.toArray可能不返回Object[]
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class)
} else {
//size==0,将elementData赋值为EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA
}
}
插入方法
1.在尾部添加一个元素
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
- 在父类AbstractList上，定义了modCount 属性，用于记录数组修改的次数。对数组进行结构化修改时modCount加一，包括添加元素，删除元素。
- 在尾部添加元素前要做的主要就两件事，第一要确保不会溢出，第二把modCount加一。调用ensureCapacityInternal函数完成这两件事。如果是使用了无参构造函数而且是第一次添加元素，会将数组扩容到默认容量10；如果是原来的数组长度小于需要的容量，会将数组扩容到原来的3/2倍。
- 将要添加的元素赋值给elementData[size],并将size加一。
2.在指定位置添加元素
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1);
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
- 如果指定位置已经有元素，就调用System.arraycopy方法，将该元素和随后的元素移动到右面一位。
3.添加元素用到的私有方法
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
扩容方法
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
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);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
- MAX_ARRAY_SIZE 定义为 Integer.MAX_VALUE - 8,ArrayList作者对所需的额外头文字的最大数量的估计为8，作为数组，在64位机器下，它本身需要8 bytes存储大小。
- 通常情况新容量是原来容量的1.5倍;如果原容量的1.5倍比minCapacity小，那么就扩容到minCapacity;特殊情况扩容到Integer.MAX_VALUE。
- Arrays.copyOf方法底层调用了System.Arraycopy方法，返回一个新数组。
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
删除方法
1.删除指定下标的元素
public E remove(int index) {
//检查下标
rangeCheck(index)
//modCount加一
modCount++
//取出要删除位置的元素，用来做返回值
E oldValue = elementData(index)
//将要删除位置之后的元素向前移动一个位，如果是最后一个元素，numMoved==0，直接将elementData[size]置空即可
int numMoved = size - index - 1
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved)
elementData[--size] = null
return oldValue
}
- 可以看到，ArrayList 中增加（扩容）或者是删除元素要调用 System.arrayCopy 这种效率很低的方法进行处理，所以如果遇到了数据量略大且需要频繁插入或删除的操作效率就比较低了。
2.删除指定元素
public boolean remove(Object o) {
if (o == null) {
for (int index = 0
if (elementData[index] == null) {
fastRemove(index)
return true
}
} else {
for (int index = 0
if (o.equals(elementData[index])) {
fastRemove(index)
return true
}
}
return false
}
- ArrayList允许元素是null值，删除指定元素需要判断要删除的是不是null值分开处理，遍历数组，如果是要删除的值，调用fastRemove方法删除。
3.删除元素用到的私有方法
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;
}
查找方法
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;
}
- 和删除指定元素类似，也要分删除的值是不是null分开处理，从头遍历数组，如果等于要查找的元素就返回位置索引。
2.查找指定位置的元素
/**
* 返回指定位置的元素
* @param index 要返回元素的位置
* @return
* @throws IndexOutOfBoundsException index越界会抛出IndexOutOfBoundsException
*/
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}
- ArrayList支持随机访问，查找指定位置的元素直接返回elementData数组指定下标的元素，时间复杂度是O(1)的。
序列化方法
1.序列化
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
int expectedModCount = modCount;
s.defaultWriteObject();
s.writeInt(size);
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
2.反序列化
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
s.defaultReadObject();
s.readInt();
if (size > 0) {
ensureCapacityInternal(size);
Object[] a = elementData;
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
- 序列化时，先写入size，再写入每一个元素；反序列化时，先读取size，再读取每一个元素。
- elementData之所以用transient修饰，是因为JDK不想将整个elementData都序列化或者反序列化，而只是将size和实际存储的元素序列化或反序列化，从而节省空间和时间。
克隆方法
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
- ArrayList的克隆是浅克隆，将全部元素复制到一个新数组返回。
迭代器
1.创建迭代器方法
public Iterator<E> iterator() {
return new Itr();
}
2.Itr类的属性
private class Itr implements Iterator<E> {
int cursor;
int lastRet = -1;
int expectedModCount = modCount;
}
3.Itr类的next方法和hasNext方法
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
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];
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
4.Itr类的remove方法
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
- foreach遍历删除会报ConcurrentModificatioinException异常。这是因为foreach遍历编译后实质会替换为迭代器实现，因为迭代器内部会维护一些索引位置数据，要求在迭代过程中不能发生结构性变换（添加、插入、删除），否则这些索引位置数据就失效了。在next方法中，会判断expectedModCount和modCount是否相同，不相同就抛异常。
- 避免的方式是使用迭代器的remove方法。因为在迭代器的remove方法里，会修改expectedModcount使之等于modCount。
- 使用迭代器删除元素时，调用 remove 方法前必须先调用 next 方法，next 方法会检测容器是否发生了结构性变化，然后更新 cursor 和 lastRet 值，直接不调用 next 而 remove 会导致相关值不正确，抛出 IllegalStateException 异常。
- 普通for循环不会报这个错误，但会漏删除。解决方法可以从后向前遍历。
参考
