目录
ArrayList
底层结构
Object[]数组，可动态变化大小
可随机访问
实现了RandomAccess接口（一个标识接口，标识实现这个类的接口具有随机访问功能），底层是因为数组存储方法时连续储存的
扩容机制
oldCapacity+oldCapacity>>1=1.5*oldCapacity
使用快速失败机制
在进行遍历过程中，使用modCount变量计算结构改变的次数，如果遍历过程中内容发生改变，modCount就会发生变化。在迭代器使用hasNext()/next()都会想检测modCount的值，如果发生了变化就会抛异常。但是如果发生变化，又刚好是相同值，就不会抛异常。
线程不安全
内存占用空间情况
ArrayList的空间浪费主要体现在list列表的结尾会预留一定容量空间，因为每次添加一次数据，就分配一次内存，如果不够分配了，需要开辟一块新的内存，整体复制现有数据，这样变得很耗时间，我们既要考虑空间优化，也要考虑时间优化。
重点方法分析
定义的常量及变量和数组
//序列号
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认长度
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 定义一个空数组，当用户指定ArrayList容量为0时，返回空数组
*/
private static final Object[] EMPTY_ELEMENTDATA = {
};
/**
* 一个空的数组实例。
* 当用户没有指定ArrayList的容量时（调用无参构造函数），返回的空的数组
* 当用户第一次添加元素的时候，该数组会扩容为默认大小->10
*
* 与EMPTY-ELEMENTDATA区别：该数组是默认返回的，而后者是指定容量为10的时候返回
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {
};
/**
* 用该数组保存数据，而数组的长度就是ArrayList的容量
* 当第一次增加元素的时候，数组会扩容为默认大小->10
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* ArrayList的实际大小
*/
private int size;
构造方法
/**
* 构造一个空的初始容量大小的数组
*
* @param initialCapacity 初始容量大小
* @throws IllegalArgumentException 如果大小为负数，则抛出该异常
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//当初始容量指定为0的时候，返回该EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
} else {
//否则，小于0抛异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 无参构造函数
* 创建一个空的ArrayList，此时长度为0
* 添加第一个元素的时候，扩容为10
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 创建一个包含collection的ArrayList，按照顺序返回
*
* @param c 被放入数组的集合
* @throws NullPointerException 如果集合为null会抛出的异常
*/
public ArrayList(Collection<? extends E> c) {
//将集合转换为数组
elementData = c.toArray();
if ((size = elementData.length) != 0) {
//c.toArray可能不会返回Object[]
if (elementData.getClass() != Object[].class)
//如果返回的不是Object[]类型，用copyOf来创建一个大小为size的Object[]数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
//换成空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}
扩容机制
/**
* 数组缓冲区最大存储容量
* 一些VM会在一个数组中存储某些数据
* 为什么-8？
* 尝试分配这个最大存储容量，可能会导致OutOfMemoryError（当该值大于VM的限制的时候）
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 扩容，确保ArrayList至少能存储minCapacity个元素
* 扩容计算：newCapacity=oldCapacity + (oldCapacity >> 1)=1.5 oldCapacity;
* @param minCapacity 指定的最小容量
*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//新容量大小
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//若newCapacity大于最大存储容量，则进行大容量分配
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 复制到新的数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
/**
* 大容量分配，最大分配Integer_MAX_VALUE
* @param minCapacity 指定的最小容量
* @return
*/
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
克隆
/**
* 深度复制：对拷贝出来的ArrayList对象操作，不会影响原来的ArrayList
*@return a clone of this <tt>ArrayList</tt> instance
*/
public Object clone() {
try {
//Object的克隆方法：会复制本对象及其内所有基本类型成员和string类型成员，但不会复制对象成员、引用对象
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
toArray()
/**
* 返回ArrayList的Object数组
* 对返回的数组进行操作，不会影响被复制的ArrayList
*/
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
/**
* 返回ArrayList元素组成的数组
* 若 a.length >= list.size，则将 list 中的元素按顺序存入 a 中，
* 然后 a[list.size] = null, a[list.size + 1] 及其后的元素依旧是 a 的元素
* @throws ArrayStoreException 当a.getClass()！=list中存储元素类型时
* @throws NullPointerException 如果a为null
*/
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
//如果数组a的大小<ArrayList的元素个数，则新建一个T[]数组，数组大小是ArrayList的元素个数
//再把ArrayList全部拷贝到新数组中
if (a.length < size)
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
//如果数组a的大小>=ArrayList的元素个数，则把ArrayList的全部元素拷贝到a中
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
get、set、remove、add
/**
* 获得指定位置的元素
*
* @param index index of the element to return
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E get(int index) {
//检查是否越界
rangeCheck(index);
return elementData(index);
}
/**
* 将index位置的元素设置为element，返回原来index位置的值
*/
public E set(int index, E element) {
//数组越界检查
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
/**
* 添加元素
*/
public boolean add(E e) {
//注意：size+1，保证资源空间不被浪费，按当前情况，保证存多少个元素就分配多少内存
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
/**
* 在index位置添加element，然后将该位置及其之后的元素往后移
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
//将elementData从下标为Index位置开始的元素，拷贝到index+1位置，拷贝size-index个
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
/**
* 移除index位置的元素
*/
public E remove(int index) {
//检查是否越界
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
//需要左移的元素个数
int numMoved = size - index - 1;
if (numMoved > 0)
// 将 elementData（源数组）从下标为 index+1 开始的元素，
// 拷贝到 elementData（目标数组）下标为 index 的位置，总共拷贝 numMoved 个
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//将最后一个元素置空
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
/**
* 删除指定的某个元素，实际上还是调用的是remove(int index)
*/
public boolean remove(Object o) {
//先找个o的索引，再调用remove(int index)
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;
}
/*
* 移除index位置上的元素
*/
private void fastRemove(int index) {
modCount++;
//要移动的元素的个数
int numMoved = size - index - 1;
if (numMoved > 0)
//将index+1位置上的元素，移到index上，共移numMoved个
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
/**
*移除数组中的所以元素
* 清空后，打印list，只会看见[]，而不是[null,null,null...]，因为toString()和迭代器进行了处理
*/
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
/**
* 将一个集合的元素全部添加到数组的末尾
* 该方法没有加锁，当一个线程正在将 c 中的元素加入 list 中，但同时有另一个线程在更改 c 中的元素，可能会有问题
*/
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
//要添加的元素个数
int numNew = a.length;
//扩容
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
/**
* 将c的全部元素添加到数组起始位置为index，但不会覆盖原来index的值
*/
public boolean addAll(int index, Collection<? extends E> c) {
//检查是否越界
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
//扩容
ensureCapacityInternal(size + numNew); // Increments modCount
//需要移动元素的个数
int numMoved = size - index;
//先移动元素，再拷贝，以免被覆盖
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
/**
*移除fromIndex~toIndex范围内的元素
*/
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
//将toIndex的元素移动到起始位置为fromIndex，移动numMoved个元素，左闭右开
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// 数组新的大小
int newSize = size - (toIndex-fromIndex);
//将newSize位置之后的元素全部置空
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
/**
* 提供给get()/remove()检查数组是否越界，如果越界则抛出异常
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 提供给add()和add()进行数组越界检查的方法
*/
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 返回异常消息，IndexOutOfBoundsException
*/
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
/**
*移除list和c中共有的元素
*/
public boolean removeAll(Collection<?> c) {
//如果c为null，则抛出空指针异常
Objects.requireNonNull(c);
return batchRemove(c, false);
}
/**
* 保留list和c中共有的元素
*/
public boolean retainAll(Collection<?> c) {
//如果c为null，则抛出空指针异常
Objects.requireNonNull(c);
return batchRemove(c, true);
}
/**
*
* @param c
* @param complement 是否取补集
* @return
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
//如果c和elementData 都有/都没有 的元素
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
forEach
@Override
public void forEach(Consumer<? super E> action) {
Objects.requireNonNull(action);
final int expectedModCount = modCount;
@SuppressWarnings("unchecked")
final E[] elementData = (E[]) this.elementData;
final int size = this.size;
//在每次到下一个元素之前，会进行一次快速失败检查，看modCount是否改变
for (int i=0; modCount == expectedModCount && i < size; i++) {
action.accept(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
Iterator
/**
* 返回一个Iterator迭代器，该迭代器是fail-fast机制
*/
public Iterator<E> iterator() {
return new Itr();
}
/**
* AbstractList.Itr的优化版本
*/
private class Itr implements Iterator<E> {
int cursor; // 下一个返回元素的索引，默认为0
int lastRet = -1; // 上一个返回元素的索引，若没有上一个元素，则为-1.每次调用remove()，lastRet都会重置为-1
int expectedModCount = modCount;
//是否有下一个元素
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
//临时变量i，指向游标当前位置
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
//检查没有问题，则将cursor指向下一个
cursor = i + 1;
//将上一个指向当前
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
//移除元素
ArrayList.this.remove(lastRet);
//回到上一个位置
cursor = lastRet;
//上一元素指针直接重置为-1.故lastRet不一定等于cursor-1
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> 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();
}
//快速失败检查机制，如果ModCount不是原来的值，则抛出异常
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}