类的继承结构
ArrayList类的定义为
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}
ArrayList上的接口都在之前的“常见接口源码”中描述了,这里不做过多描述
重要的成员变量
// 默认容量 通过new ArrayList()创建时的默认容量
private static final int DEFAULT_CAPACITY = 10;
// 空数组,如果传入的容量为0时使用
private static final Object[] EMPTY_ELEMENTDATA = {};
// 空数组,传传入容量时使用,添加第一个元素的时候会重新初始为默认容量大小
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 存储元素的数组
transient Object[] elementData;
// 集合中元素的个数 真正存储元素的个数,而不是elementData数组的长度
private int size;
可以看到ArrayList实际上就是对普通对象数组的一个封装,elementData与size表达其数据。其套路与String类似,底层使用char[]进行存储。
构造方法
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
// 如果传入的初始容量大于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);
}
}
public ArrayList() {
// 如果没有传入初始容量,则使用空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA
// 使用这个数组是在添加第一个元素的时候会扩容到默认大小10
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 把传入集合的元素初始化到ArrayList中
*/
public ArrayList(Collection<? extends E> c) {
// 集合转数组
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// 检查c.toArray()返回的是不是Object[]类型,如果不是,重新拷贝成Object[].class类型
// 子类有可能覆盖toArray方法,类似得到 String[]的结果
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 如果c的空集合,则初始化为空数组EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
}
}
可以看到,构造方法有三种:
- 一个是无参构造,将默认空数组对象赋值到elementData,在首次添加数据的时候自动扩充到10;
- 以初始容量作为参数传递,先判定容量有效值,然后对等于0或者大于0的场合进行分类执行【】
- 以集合作为参数传递,将会使用集合内的数据作为当前列表的数据进行存储。
重要实例方法
增加元素
向容器内增加元素有四种方式:
- 向线性表尾部增加元素 : add(E e)
- 向线性表尾部批量增加元素:addAll(Collection<? extendsE> c)
- 向线性表每个位置增加元素:add(int index, E element)
- 向线性表某个位置批量增加元素 : addAll(int index, Collection<? extendsE> c)
接下来我们一个一个分析,首先是在尾部增加一个元素:
public boolean add(E e) {
// 检查是否需要扩容
ensureCapacityInternal(size + 1);
// 把元素插入到当前size后一位
elementData[size++] = e;
return true;
}
// 检查是否需要扩容
// 这个方法也会在addAll中出现,初始化之后就可能塞一大坨东西进来,因此会有比较默认10和传参之间比较的逻辑存在
private void ensureCapacityInternal(int minCapacity) {
// 如果是空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA,就初始化为默认大小10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 比较10 和 传入的哪个大,得到最大的那个
// 一般情况下都是10,
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
// 扩容
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// 新容量为旧容量的1.5倍
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);
}
可以看到,首先需要进行扩容判定,如果需要扩容,则将底层的对象数组扩充至原先的1.5倍长度,这里需要注意避免超出最大值。然后在size+1的位置赋值新元素即可。
第二种是在尾部批量新增元素:
/**
* 将集合c中所有元素添加到当前ArrayList中
*/
public boolean addAll(Collection<? extends E> c) {
// 将集合c转为数组
Object[] a = c.toArray();
int numNew = a.length;
// 检查是否需要扩容
ensureCapacityInternal(size + numNew);
// 将c中元素全部拷贝到数组的最后
System.arraycopy(a, 0, elementData, size, numNew);
// 大小增加c的大小
size += numNew;
// 如果c不为空就返回true,否则返回false
return numNew != 0;
}
可以看到逻辑与新增单个元素类似,先获得到传入的批量元素大小,然后判定是否需要扩容,然后使用System.arraycopy将目标集合内的元素拷贝至尾部。
第三种是在指定位置上新增元素:
public void add(int index, E element) {
// 检查是否越界
rangeCheckForAdd(index);
// 检查是否需要扩容
ensureCapacityInternal(size + 1);
// 将inex及其之后的元素往后挪一位,则index位置处就空出来了
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 将元素插入到index的位置
elementData[index] = element;
// 大小增1
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
可以看到其逻辑是先判定是否需要扩容,然后将elementData内在位置之后的数据使用System.arraycopy往后移位。然后在原有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)
//原有数组index位置开始,往后挪numMoved个单位
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
// 将这个集合拷贝到index的位置
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
同理先进行扩容判定,然后利用System.arraycopy将index位置之后的数据往后移动目标集合的长度。再利用System.arraycopy将目标数据拷贝至index处。
删除元素
删除元素可以使用索引或者元素本身进行查找并删除。如下是基于索引进行删除元素,先判定index是否符合规范,随后抽取index位置的数据到局部变量,然后使用System.arraycopy将index之后的数据往前移动一位。
public E remove(int index) {
// 检查是否越界
rangeCheck(index);
modCount++;
// 获取index位置的元素
E oldValue = elementData(index);
// 如果index不是最后一位,则将index之后的元素往前挪一位
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
// 将最后一个元素删除,帮助GC
elementData[--size] = null; // clear to let GC do its work
// 返回旧值
return oldValue;
}
在集合中也可以指定元素进行删除,那么意味着需要进行遍历找到其位置。逻辑如下,如果传入为null,则开始遍历寻找第一个为null的元素,并进行快速删除,由于处在遍历过程中因此不需要进行越界检查,这也是fastRemove的含义。如果传入不是一个null,则使用Object#equal的方式进行比对,比对成功则同样调用fastRemove进行删除。fastRemove内执行删除后,会将位置之后的数据往前移动一位。
public boolean remove(Object o) {
if (o == null) {
// 遍历整个数组,找到元素第一次出现的位置,并将其快速删除
for (int index = 0; index < size; index++)
// 如果要删除的元素为null,则以null进行比较,使用==
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
// 遍历整个数组,找到元素第一次出现的位置,并将其快速删除
for (int index = 0; index < size; index++)
// 如果要删除的元素不为null,则进行比较,使用equals()方法
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
private void fastRemove(int index) {
// 少了一个越界的检查
modCount++;
// 如果index不是最后一位,则将index之后的元素往前挪一位
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
// 将最后一个元素删除,帮助GC
elementData[--size] = null; // clear to let GC do its work
}
修改元素
set方法是基于位置进行替换的,替换成功则返回旧值。
public E set(int index, E element) {
rangeCheck(index);
//得到旧值
E oldValue = elementData(index);
//替换
elementData[index] = element;
return oldValue;
}
查询元素
查询元素的逻辑实际上就隐含在删除逻辑内,毕竟得先找到才能删除。同样的,可以使用下标或者元素本身进行查找。使用下标会返回对应的索引,使用元素查找将会返回元素在列表内的索引,如果找不到则返回-1。
基于索引查找的逻辑如下:
public E get(int index) {
// 检查是否越界
rangeCheck(index);
// 返回数组index位置的元素
return elementData(index);
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
return (E) elementData[index];
}
基于元素查找的逻辑如下:
//使用元素进行匹配,得到index值
public int indexOf(Object o) {
//如果传入为null,之后使用==进行判断
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
//否则使用equals方法遍历判断
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
//如果没有匹配的元素则返回-1
return -1;
}
index是从0开始进行查询的,lastIndexOf则是从尾部进行遍历:
//相当于 indexOf 从末尾开始遍历
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;
}
集合操作
在数学概念上,集合会有三种集合操作,分别是并集,交集,补集。其中并集可以使用addAll满足,但是需要注意list集合并不会去重。与数学概念上等价的集合实际上是set。
交集操作
public boolean retainAll(Collection<?> c) {
// 集合c不能为null
Objects.requireNonNull(c);
// 调用批量删除方法,这时complement传入true,表示删除不包含在c中的元素
return batchRemove(c, true);
}
/**
* 批量删除元素
* complement为true表示删除c中不包含的元素
* complement为false表示删除c中包含的元素
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
// 使用读写两个指针同时遍历数组
// 读指针每次自增1,写指针放入元素的时候才加1
// 这样不需要额外的空间,只需要在原有的数组上操作就可以了
int r = 0, w = 0;
boolean modified = false;
try {
// 遍历整个数组,如果c中包含该元素,则把该元素放到写指针的位置(以complement为准)
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// 正常来说r最后是等于size的,除非c.contains()抛出了异常
if (r != size) {
// 如果c.contains()抛出了异常,则把未读的元素都拷贝到写指针之后
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// 将写指针之后的元素置为空,帮助GC
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
// 新大小等于写指针的位置(因为每写一次写指针就加1,所以新大小正好等于写指针的位置)
size = w;
modified = true;
}
}
// 有修改返回true
return modified;
}
补集操作
public boolean removeAll(Collection<?> c) {
// 集合c不能为空
Objects.requireNonNull(c);
// 同样调用批量删除方法,这时complement传入false,表示删除包含在c中的元素
return batchRemove(c, false);
}