在工作中,ArrayList算是一个比较常用的Java集合工具类了,本文主要聊聊其存取的工作原理。先看继承结构:
可以看出,ArrayList继承了AbstractList,并且实现了List, RandomAccess, Cloneable, java.io.Serializable,除了List接口,其他3个接口都是标记接口。奇怪的是AbstractList已经实现了List接口,ArrayList既然已经继承了AbstractList,自然是没有必要再去实现List接口的,据了解,是遗留问题。
下面开始正题:
一、从构造方法开始看起
1.相关属性
/**
* 默认初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 空数组实例
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 空数组实例,和上面那个作用不一样
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 存储集合元素的数组
*/
transient Object[] elementData;
/**
* 集合大小
*/
private int size;
2.构造函数
(1)无参构造,初始化一个空数组,表示会使用默认容量为10
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
(2)指定容量,根据指定的初始容量创建数组,注意一下容量为0,使用的是EMPTY_ELEMENTDATA
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);
}
}
(3)根据集合初始化,只是数据的搬运而已
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;
}
}
二、添加元素
1. 在集合后面添加元素
public boolean add(E e) {
// 确保容量足够,修改计数器+1
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
重点看:ensureCapacityInternal
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
在这里就可以看出一点了,DEFAULTCAPACITY_EMPTY_ELEMENTDATA和EMPTY_ELEMENTDATA是有区别的,起码在这里,表示,如果我们创建集合的时候,使用了默认的构造器,那么在添加第一个元素的时候,才会创建一个大小为10的默认数组,而不是一开始就创建了大小为10的数组。
接着看:ensureExplicitCapacity
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
看到当容量不够时,就会进行扩容grow:
private void grow(int minCapacity) {
// 旧容量,原数组长度
int oldCapacity = elementData.length;
// 新容量,并不一定等于旧容量的1.5倍,只是(旧容量+旧容量/2)
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);
}
这个复制算法,跟进去是System类的一个native方法:
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
自己都可以实现,只是一个数据搬移过程
2.在指定位置添加元素
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
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));
}
然后空出index位置,怎样空出index位置呢?将index及其后面的元素往后移动即可,注意从最后一个元素开始
三、获取元素
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
两步:
(1)检查下标
(2)根据下标获取元素
四、删除元素
1.根据下标删除
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;
}
(1)检查下标
(2)拿到要删除的元素
(3)移动数组元素(这里是复制)
2.根据元素移除
和根据下标移除,多了一个遍历过程,最后还是根据下标移除的
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;
}