ArrayList 集合类，用于储存元素。底层是基于数组实现的，
所以拥有了数组的优点：
- 查询快(通过索引下标)
- 允许空值和重复值
- 有序(按照插入顺序连续存储)
缺点也是难免的，比如：
- 插入和删除慢(数组要保证内存的连续性，每次插入和删除需要搬迁元素)
- 容量的不确定性(每当数组容量不足时，会按照当前数组容量的1.5倍进行扩容)
- 非线程安全(add()，remove() 等方法，没有加锁机制，并发操作保证不了集合的原子性) 。
层级图
属性/构造方法源码
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
/**
* Fail-Fast 机制: modCount主要是为了防止在迭代过程中通过List的方法（非迭代器）
* 改变了原集合(结构修改)，导致出现不可预料的情况，从而提前抛出并发修改异常，
*
* 在 ArrayList类中，可以改变原集合的非迭代器方法有： add、remove、removeIf、removeAll、
* retainAll、replaceAll、clear、sort、trimToSize、ensureCapacity
*/
protected transient int modCount = 0;
}
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
/**
* 默认初始容量。
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 共享的空数组实例，供有参构造器使用，将其与无参构造器区分开来
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 共享的空数组实例，供无参构造器使用，将其与其他构造器区分开来
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 存储 ArrayList元素的数组。
* transient（序列化时忽略该数组）
*/
transient Object[] elementData;
/**
* ArrayList中实际存储的元素数量。
*/
private int size;
/**
* 容量上限值：2147483639
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 对 elementData属性进行初始化，容量为0。
* 当第一次执行 add方法时，数组扩容，扩容后数组长度 = DEFAULT_CAPACITY
*
* 之后每当数组容量已满时（即elementData.length == size），
* 则按当前 elementData容量的1.5倍进行扩容。
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 根据入参，初始化 elementData 容量。
* (如果入参为0，则对 elementData属性进行初始化，容量为0。
* 当第一次执行 add方法时，需进行数组扩容，扩容后数组长度 = 1)
*
* 之后每当数组容量已满时（即elementData.length == size），
* 则按当前 elementData容量的1.5倍进行扩容。
*
* @param initialCapacity 列表的初始容量
* @throws IllegalArgumentException
*/
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);
}
}
/**
* 根据入参集合长度，初始化 elementData 容量，并将入参集合内容保存到 elementData。
* (如果集合长度为0，则对 elementData属性进行初始化，容量为0。
* 当第一次执行 add方法时，数组扩容，扩容后数组长度= 1)
*
* 之后每当数组容量已满时（即elementData.length == size），
* 则按当前 elementData容量的1.5倍进行扩容。
*
* @param c 要将其元素放入该列表的集合
* @throws NullPointerException
*/
public ArrayList(Collection<? extends E> c) {
// 集合转数组，赋值给 elementData[]
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// 若 c.toArray()的返回值不是 Object[]类型
if (elementData.getClass() != Object[].class)
// 则调用 Arrays.copyOf方法将其转为 Object[]，防止添加数据时抛出异常
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
this.elementData = EMPTY_ELEMENTDATA;
}
}
/**
* 总结：
* DEFAULTCAPACITY_EMPTY_ELEMENTDATA 和 EMPTY_ELEMENTDATA 的区别在于，在扩容时：
* DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是以 10为基准进行扩容；
* EMPTY_ELEMENTDATA 是以有参构造器的初始容量(参数)为基准进行扩容；
*/
}
add(E e)
源码注释
执行逻辑：
-
调用无参构造器 ArrayList() 时，创建对象。初始化 this.elementData = {}
-
执行 add(E e)
-
调用 ensureCapacityInternal(int minCapacity)，确定数组所需的存储空间大小
-
调用 ensureExplicitCapacity(int minCapacity)，判断数组中是否存在未使用的存储空间
- 不存在：调用 grow(int minCapacity)，执行数组扩容方法
- 存在：则退回 add(E e)，执行语句 elementData[size++] = e; 元素添加成功
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
/**
* 将指定的元素追加到数组末尾。
*/
public boolean add(E e) {
// size + 1, 表示原本已经存储了x个元素，现在执行add()，那最小还需要x+1个存储空间。
ensureCapacityInternal(size + 1);
// 添加元素
elementData[size++] = e;
return true;
}
/**
* 确定是否需要扩容：确保内部容量
* @param minCapacity 所需的最小容量, 第一次添加, 入参为1
* 所需的最小容量, 第二次添加, 入参为2
* 所需的最小容量, 第11次添加, 入参为11
*/
private void ensureCapacityInternal(int minCapacity) {
// 如果 elementData 为空数组(第一次添加)，且是通过无参构造器创建的。
// 则将数组所需的最小容量设置为10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
* 确定是否需要扩容：确保显式容量
* @param minCapacity
* 所需的最小容量, 第一次添加, 入参为10; 当前 elementData.length=0 执行扩容
* 所需的最小容量, 第二次添加, 入参为2; 当前 elementData.length=10
* 所需的最小容量, 第十一次添加, 入参为11; 当前 elementData.length=10 执行扩容
*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
// 数组当前容量不足，需执行扩容方法
grow(minCapacity);
}
/**
* 增加容量，以确保它至少可以容纳最小容量参数指定的元素数量。
*
* @param minCapacity 所需的最小容量，第一次扩容 minCapacity = 10
* 所需的最小容量，第二次扩容 minCapacity = 11
*/
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// 按照1.5倍大小扩容， (oldCapacity >> 1) 表示：当前数组大小除以2
// 第一次扩容：oldCapacity=0， minCapacity=10，扩容后数组容量 newCapacity = 10
// 第二次扩容：oldCapacity=10，minCapacity=11，扩容后数组容量 newCapacity = 15
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 执行数组扩容，底层使用的是 System.arraycopy方法
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
// elementData 容量上限 -> 2147483647 : 2147483639
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
}
图解
扩容机制图示↓
通过 ArrayList的无参构造器创建集合对象，底层通过 Object[] elementData 保存元素，默认为空。
第一次执行 add(1)方法时，elementData[] 容量初始化为10。之后无限循环执行 add(1)方法，测试集合容量上限（当elementData[] 容量已满时，即length=size。则下一次执行add()方法时，数组容量将扩容1.5倍），如下图：
图例：
oldLength 为elementData[] 容量
oldSize 为elementData[] 实际存储的元素数量
newLength 为elementData[] 扩容后的容量
newSize 为elementData[] 扩容后实际存储的元素数量
... 表示省略中间add() 执行结果
add(int index, E element)
源码注释
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
/**
* 根据索引在指定位置插入指定的元素。
*/
public void add(int index, E element) {
// 数组下表越界检查
rangeCheckForAdd(index);
// 扩容逻辑，同 add(E e) 相同
ensureCapacityInternal(size + 1);
// 如上图 index = 2, size = 6
// 则 从 elementData源数组下标2 开始拷贝，拷贝到 elementData目标数组，下标 (2 + 1)
// 总共需要拷贝 (6-2) 个元素。
System.arraycopy(elementData, index, elementData, index + 1, size - index);
// 将新元素添加到指定下标
elementData[index] = element;
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
remove(int index)
源码注释
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
/**
* 根据索引从数组中删除指定元素。
*/
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);
// 将数组中最后一个元素置为 null
elementData[--size] = null;
return oldValue;
}
E elementData(int index) {
return (E) elementData[index];
}
}
iterator()
按正确的顺序在此列表中的元素上返回迭代器。
public static void main(String[] args) {
String[] arr = {"A", "B", "C", "D", "E"};
ArrayList<String> list = new ArrayList<>();
for (String s : arr) {
list.add(s);
}
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
String next = (String) iterator.next();
System.out.println(next);
if ("C".equals(next)) {
iterator.remove();
}
}
}
源码注释
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
int cursor; // 指向下一个元素的索引
int lastRet = -1; // 指向当前元素; -1表示没有
int expectedModCount = modCount;
// 判断是否存在可访问的元素，存在则返回true
public boolean hasNext() {
return cursor != size;
}
// 返回将要访问的下一个元素。
// 如果被非迭代器方法修改了集合，将提前抛出并发修改异常 ConcurrentModificationException
// 如果到达了集合末尾，还继续访问，将抛出 NoSuchElementException
@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];
}
// 从集合中删除当前返回的元素
public void remove() {
// Iterator强制在使用 remove()方法前要先执行 next()方法为 lastRet赋值，
// 否则lastRet = -1，抛出异常
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
// 删除当前元素
ArrayList.this.remove(lastRet);
// 元素删除后会重新创建底层数组，将旧数组的值拷贝到新数组中，后续元素全部左移一位。
// 因此，cursor需要在每次执行删除后得到修正，即 cursor=lastRet。
cursor = lastRet;
// lastRet = -1 是为了阻止在没有进行 next()的情况下连续执行remove()，只有再次
// 执行 next()后，lastRet完成刷新，remove()才知道应该删除哪个元素。
lastRet = -1;
// 同步 modCount
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
// modCount 检查
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
}
subList(int fromIndex, int toIndex)
源码注释
执行逻辑：
- 调用subList(int fromIndex, int toIndex) 时，会通过 SubList的构造函数创建对象。
- 构造函数将外部类ArrayList中的部分属性直接赋给自己，最终返回介于fromIndex（包含）到 toIndex（排除）之间的部分视图。
注：如果直接对list进行结构性修改后，使用sList时，会抛出异常ConcurrentModificationException。这是因为对AarrayList进行修改时，并不会同步 SubList中的 modCount属性，因此在执行 checkForComodification()方法时，会抛出异常。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
/**
* 返回此列表中介于fromIndex（包含）到 toIndex（排除）之间的部分视图。
*
* @return 返回值的编译类型是List，运行类型是内部类SubList
* @throws IndexOutOfBoundsException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
*/
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
private class SubList extends AbstractList<E> implements RandomAccess {
private final AbstractList<E> parent;
private final int parentOffset;
private final int offset;
int size;
SubList(AbstractList<E> parent, int offset, int fromIndex, int toIndex) {
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount = ArrayList.this.modCount;
}
/**
* SubList类，单独定义了set、get、add、remove等方法，这些方法实际上依然使用的是
* ArrayList类中相对应的方法。
* 这是因为SubList类不保存数据，而是通过指定范围的方式直接引用了ArrayList的部分视图。
*
* @return 返回值的编译类型是List，运行类型是内部类SubList
* @throws IndexOutOfBoundsException {@inheritDoc}
* @throws ConcurrentModificationException {@inheritDoc}
*/
public E remove(int index) {
rangeCheck(index);
checkForComodification();
E result = parent.remove(parentOffset + index);
this.modCount = parent.modCount;
this.size--;
return result;
}
private void rangeCheck(int index) {
if (index < 0 || index >= this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private void checkForComodification() {
if (ArrayList.this.modCount != this.modCount)
throw new ConcurrentModificationException();
}
}
}
963
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
