ArrayList是基于数组进行实现的,数组的默认大小为10.
/**
* 默认初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
下面介绍下ArrayList的扩容机制,这里以在指定位置插入新的元素为样例,主要代码如下面几行所示:
/**
* 在指定位置插入元素
*/
public void add(int index, E element) {
rangeCheckForAdd(index); // 检查范围
ensureCapacityInternal(size + 1); // Increments modCount!! // 确保容量足够
System.arraycopy(elementData, index, elementData, index + 1,
size - index); // index开始后面的元素全部向后移动一位
elementData[index] = element; // 插入元素
size++;
}
// 确保容量足够的函数
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 计算容量的函数
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 如果没有定义长度的ArrayList
return Math.max(DEFAULT_CAPACITY, minCapacity); // 如果容量minCapacity小于默认容量,就设置为默认容量
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++; // 修改次数+1
// overflow-conscious code
if (minCapacity - elementData.length > 0) // 需要进行扩容的话
grow(minCapacity); // 进行扩容
}
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length; // 原始数组长度
int newCapacity = oldCapacity + (oldCapacity >> 1); // 新的长度是原来的1.5倍
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) {
if (minCapacity < 0) // overflow // 违规变量
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ? // 最大容量
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
扩容的主要步骤如下:
主要知识点总结:
下面介绍下删除操作,这里以移除指定位置的元素为样例,具体代码如下所示:
/**
* 移除指定位置的元素
*/
public E remove(int index) {
rangeCheck(index); // 检查范围
modCount++; // 修改次数+1
E oldValue = elementData(index); // 旧的值
int numMoved = size - index - 1; // 需要移动元素的个数
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved); // index后的元素全部向前移动一位
elementData[--size] = null; // clear to let GC do its work 最后一个元素设置为null
return oldValue;
}
主要步骤:
我们根据具体的代码来看两者的区别:
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
modCount在ArrayList的代码里面经常出现,它**主要用来记录数据的修改次数,应用于多线程情况下使用迭代器。在使用迭代器的时候,线程1首先会设置expectModCount=modCount。当线程1查看了当前数据,然后挂起。线程2这时对于数据进行了修改,这时modCount+1.当线程1继续访问,便会发现expectModcount != modCount。这时就会直接报错,也就是我们常说的fail-fast机制**。