ArrayList源码解析
前言
这里首先建议小伙伴们自己去阅读源码，然后有条件的可以自己手写一遍，先看，然后根据自己的感觉去写，不会的可以抄源码，但是要知道这段代码的作用是什么。
ArrayList源码解析
ArrayList简介
ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
它继承于 AbstractList，实现了 List, RandomAccess, Cloneable, java.io.Serializable 这些接口。
ArrayList 继承了AbstractList，实现了List。它是一个数组队列，它将数组队列中，一部分公共方法抽取出来，进行抽象实现，这就使得用户在自定义实现集合的时候，可以不用修改核心代码，只要添加自己需要的部分就行了。
ArrayList 实现了RandomAccess 接口， RandomAccess 是一个标志接口，表明实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
ArrayList 实现了Cloneable 接口，即覆盖了函数 clone()，能被克隆（没有实现这个接口调用Object.clone()方法会抛出不可克隆异常）。
ArrayList 实现java.io.Serializable 接口，这意味着ArrayList支持序列化，能通过序列化去传输。
和 Vector 不同，ArrayList 中的操作不是线程安全的！所以，建议在单线程中才使用 ArrayList，而在多线程中可以选择 Vector 或者 CopyOnWriteArrayList。
ArrayList核心源码
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
/**
* 默认的初始大小
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 空数组，相当于一个空的实例
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
//用于默认大小空实例的共享空数组实例。
//我们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量需要增加多少。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 可以看到，ArrayList底层是用一个Oejct数组存储元素的。
transient Object[] elementData; /
// 集合的大小
private int size;
// 构造方法，根据传入的大小，为数组分配大小，否则赋予一个空实例，
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() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
//如果指定集合元素个数不为0
if ((size = elementData.length) != 0) {
// c.toArray 可能返回的不是Object类型的数组所以加上下面的语句用于判断，
if (elementData.getClass() != Object[].class)
// 将c数组复制为一个Object数组
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 赋予一个空的实例
this.elementData = EMPTY_ELEMENTDATA;
}
}
// 修改这个ArrayList实例的容量是列表的当前大小。 应用程序可以使用此操作来最小化ArrayList实例的存储。
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//下面是ArrayList的扩容机制
//ArrayList的扩容机制提高了性能，如果每次只扩充一个，
//那么频繁的插入会导致频繁的拷贝，降低性能，而ArrayList的扩容机制避免了这种情况。
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
// 获得需要扩容的最小容量
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 static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
// 对数组扩容
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);// 位运算，将数组扩容至原来的1.5倍，>> 1就是往右移一位，/2
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) {
// 超出int的最大范围变为负数
if (minCapacity < 0) // overflow，OOM了
throw new OutOfMemoryError();
// 判断所需要的最小容量是否超过了定义的最大数组的值，是就返回int的最大范围
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
// 返回集合的容量
public int size() {
return size;
}
// 判断集合是否为空
public boolean isEmpty() {
return size == 0;
}
// 用indexOf判断集合是否包含某个元素
public boolean contains(Object o) {
// indexOf 查找元素在集合中第一次出现的位置，没有就返回-1
return indexOf(o) >= 0;
}
// 查找元素在集合中第一次出现的位置
public int indexOf(Object o) {
// 集合中支持存储null 元素，所以需要判断一下
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;
}
// 返回元素在集合中最后一次出现的位置
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
// 拷贝一个新的ArrayList实例（不拷贝内容），浅拷贝
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size); // 复制一份数组
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// 不应该发生此异常，因为实现了cloneable接口
throw new InternalError(e);
}
}
/*
以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
返回的数组将是“安全的”，因为该列表不保留对它的引用。 （换句话说，这个方法必须分配一个新的数组）。
因此，调用者可以自由地修改返回的数组。 此方法充当基于阵列和基于集合的API之间的桥梁。
*/
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
/**
* 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）;
*返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组，则返回其中。
*否则，将为指定数组的运行时类型和此列表的大小分配一个新数组。
*如果列表适用于指定的数组，其余空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。
*（这仅在调用者知道列表不包含任何空元素的情况下才能确定列表的长度。）
*/
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
// Positional Access Operations
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
// 返回集合中指定位置的元素
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
// 替换指定位置的元素
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
// 为集合中添加一个元素
public boolean add(E e) {
// 判断是否需要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//这里看到ArrayList添加元素的实质就相当于为数组赋值
elementData[size++] = e;
return true;
}
// 为集合中的指定位置添加一个元素
public void add(int index, E element) {
rangeCheckForAdd 对index进行界限检查；
rangeCheckForAdd(index);
// 同样判断是否需要扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
// 这个的是实现和普通的add不一样，需要将想要插入的位置后面的元素往后移动
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
// rangeCheckForAdd 对index进行界限检查；然后调用 ensureCapacityInternal 方法保证capacity足够大；
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;
}
/*
从列表中删除指定元素的第一个出现（如果存在）。 如果列表不包含该元素，则它不会更改。
返回true，如果此列表包含指定的元素
*/
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; // 将对象的引用为null，方便GC
}
// 清空集合
public void clear() {
modCount++;
// 将一个元素都指向null，方便GC工作
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
// 按指定集合的Iterator返回的顺序将指定集合中的所有元素追加到此列表的末尾。
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;
}
// 在指定位置插入新的集合
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;
}
// 删除指定区间中的元素
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
// 将任何后续元素移动到左侧（减少其索引）
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
// 检查给定的索引是否在范围内。
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// add和addAll使用的rangeCheck的一个版本
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;
}
// 删除给定集合中包含的所有元素
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
// 返回本集合与给定集合中共有的元素，取交集，不在交集中的元素会被删除
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
// 取交集的核心方法
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++)
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;
}
// 返回一个列表迭代器，支持在便利的过程中对集合进行操作
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
// 返回列表中的列表迭代器
public ListIterator<E> listIterator() {
return new ListItr(0);
}
// 返回一个普通的迭代器，不支持在遍历的过程中对元素进行修改
public Iterator<E> iterator() {
return new Itr();
}
}
并发修改异常 ConcurrentModificationException
观察源码我们可以发现，List集合中有一个modCount变量，每次对集合进行修改都会将modCount++，我们看一个小例子。
public class iteratorTest {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9));
for (int i = 0; i < 30; i++) {
if (i % 2 == 0) {
new Thread(() -> list.add(9)).start();
} else {
final int b = i % list.size();
new Thread(() -> list.set(b, 8)).start();
}
}
for (Integer i : list) {
System.out.println(i);
}
}
}
我首先开了30个线程对list集合进行了并发的修改，然后最后对list进行遍历，遍历的结果如下：
我们可以看到报错了，ConcurrentModificationException并发修改异常。然后我们再用另一种方式对list进行遍历：
public class iteratorTest {
public static void main(String[] args) throws IOException {
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9));
for (int i = 0; i < 30; i++) {
if (i % 2 == 0) {
new Thread(() -> list.add(9)).start();
} else {
final int b = i % list.size();
new Thread(() -> list.set(b, 8)).start();
}
}
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
结果:
没有报错。下面我们来解释一下为什么会这样。
foreach循环
java的foreach循环其实就是将被循环的数组或者集合转成一个iterator迭代器进行迭代，此时是不允许对数组或集合进行修改的(add,remove)，如果进行修改，就会报ConcurrentModificationException异常
// 我这里将并发修改的代码注释了，变成再foreach循环中进行修改
public static void main(String[] args) throws IOException {
List<Integer> list = new ArrayList<>(Arrays.asList(1,2,3,4,5,6,7,8,9));
//
//for (int i = 0; i < 30; i++) {
// if (i % 2 == 0) {
// new Thread(() -> list.add(9)).start();
// } else {
// final int b = i % list.size();
// new Thread(() -> list.set(b, 8)).start();
// }
//}
for (Integer integer : list) {
list.add(5);
}
报错如下：
和并发修改发生的异常一样。
为什么会出现ConcurrentModificationException异常
我们来看一下迭代器的方法：
next():
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
// 每一次遍历的时候，会先调用hasNext进行检查
public boolean hasNext() {
return cursor != size;
}
// 检查完毕调用next方法
@SuppressWarnings("unchecked")
public E next() {
// 此方法会检查modcount
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];
}
checkForComodification():
final void checkForComodification() {
// expectedModCount是迭代器内部的一个变量，每次对集合进行操作，都会让expectedModCount与modCount同步
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
看完上面这两个方法，大概就能明白为什么在迭代遍历的时候对集合修改会引发异常(也不能说是在遍历的时候，是遇到checkForComodification()方法)。我们知道，每次对集合的操作会让modCount++，那当迭代器调用next()方法时，它会首先进行checkForComodification()检查，如果expectedModCount与modCount的值不一样，证明集合已经被并发修改了，就会抛出并发修改的异常。
扫一扫
218
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
