说明:这个文章是我个人的学习笔记,由于本人水平有限,如果有什么误导的地方,请指正,谢谢
前提
- 对常用的集合进行复习分析,如,ArrayList、LinkedList、Vector
ArrayList
- ArrayList是基于数组实现,可以允许为空,元素可以重复,是有序集合,但是非线程安全
- UML图
- 基本属性
// 默认的初始化容量
private static final int DEFAULT_CAPACITY = 10;
// ArrayList 的元素存储的数组缓冲区,存储的对象数组f(transient 关键字是为了该属性不会被序列化,有时间再研究看看为什么)
transient Object[] elementData; // non-private to simplify nested class access
// 数组长度
private int size;
- 初始化的方式
Array的初始化方式有三种,分别是 无参数直接初始化、指定大小初始化、指定初始数据初始化,具体的源码- 指定大小初始化,根据传入参数>0,来初始化一个初始容量为initialCapacity的数组,=0则初始化为空数组,<0抛出异常
- 无参构造,elementData初始化为空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA,第一次调用add方法,则会扩容为DEFAULT_CAPACITY=10
- 指定初始数据初始化,就是将Collection集合中的元素变为数组的形式
// 构造一个具有指定初始容量的空列表(指定大小初始化)。
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);
}
}
// 构造一个初始容量为 10 的空列表,但是初始容量是在第一次add的时候才会指定(无参数直接初始化)
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 构造一个包含指定集合元素的列表
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
-
新增方法,add(),方法有两种一个是直接在数组的末尾追加,一种是在任意位置添加,源码如下
- 计算数组容量,是否超出最大值
- 如果当前数组为空,则初始化容量为DEFAULT_CAPACITY=10
- 如果超出了容量最大值,则开始进行扩容
- 扩容为原来容量的1.5倍
- 如果发生扩容,将原数组中的元素拷贝
// 在数组的末尾追加
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
// 指定位置添加
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
// 将 index 及其之后的所有元素都向后移一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 在指定位置插入元素
elementData[index] = element;
size++;
}
这里注意一下方法ensureCapacityInternal,这个方法是确认数组的容量大小,如果超过了初始容量,则需要扩容,数组的扩容会导致整个数组进行一次内存复制。 接下来继续分析扩容的方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 如果当前数组为空,则初始容量为DEFAULT_CAPACITY=10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
// 否则返回当前数组容量(加上了当次的新增的数量)
return minCapacity;
}
// 确认容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 所以首次add ,则需要走grow方法
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 扩容
private void grow(int minCapacity) {
// overflow-conscious code
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);
}
- get方法没什么好说的就是在数组里面根据下标返回,所以获取元素的效率非常高
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
public E get(int index) {
// 检查是否下标越界
rangeCheck(index);
return elementData(index);
}
- remove方法,删除数组元素,删除元素有很多种方式,比如根据数组索引删除、根据值删除或批量删除等等,原理和思路都差不多。
ArrayList在每一次有效的删除元素操作之后,都要进行数组的重组,并且删除的元素位置越靠前,数组重组的开销就越大。
// 根据索引位置删除
public E remove(int index) {
rangeCheck(index);
modCount++;
// 删除的值
E oldValue = elementData(index);
// 这个值表示,需要从index后移动多少个元素到前面去,-1是因为下标从0开始
int numMoved = size - index - 1;
if (numMoved > 0)
// 拷贝数组,从index+1的位置开始拷贝,拷贝的起始位置是index(就是删除所在的位置),长度是numMoved
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 数组的最好一个位置赋值为null,等待GC
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
// 根据元素删除
public boolean remove(Object o) {
if (o == null) {
// 如果删除的元素是null,则进行遍历,删除第一个值为null的元素,也是根据下标删除
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
// 删除不为null的元素,则进行遍历,取和o进行equals一样的元素删除
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
总结
- ArrayList是一种变长集合类,基于数组实现,随机提取元素的效率高,默认构造方法的初始容量为10,但是是延迟初始化,是第一次add的时候,才会初始化容量
- ArrayList允许元素为空,也重复元素
- ArrayList添加元素的时候,如果元素数量大于数组容量,则进行扩容,扩容的长度为原来的1.5倍
- ArrayList非线程安全类,多线程环境下,可能会引发不可预知的错误
- 有序集合,因为删除和随机插入都需要复制数组,性能可能比较差