ArrayList
1. 实现及底层数据结构
(1)ArrayList实现
- 继承了AbstractList抽象类
- 实现List接口
- 实现RandomAccess接口:标识为支持快速访问
- 实现Cloneable:覆盖clone(),支持被克隆
- 实现了java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
}
(2)底层数据结构
- 底层是Object数组存储
- 最大容量 Integer.MAX_VALUE
transient Object[] elementData;
2. 源码解析
主要成员变量
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数据的数组
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* ArrayList 所包含的元素个数
*/
private int size;
构造函数
(1)无参构造函数
- 数组赋值为DEFAULTCAPACITY_EMPTY_ELEMENTDAT
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
(2)有参构造函数(int initialCapacity)
- 参数大于0,创建指定参数大小的数组
- 参数等于0,赋值为EMPTY_ELEMENTDATA
- 参数小于0,抛出异常
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)有参构造函数(Collection<? extends E> c)
- 集合长度 > 0 :通过Arrays.copyOf进行复制
- 集合长度 = 0 :赋值为EMPTY_ELEMENTDATA
public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
扩容机制
(1)扩容的大小
- 扩容原来的1.5倍:int newCapacity = oldCapacity + (oldCapacity >> 1);
(2)扩容主要过程
- 调用add()进行添加元素
- 将当前元素数量+1作为所需最小容量参数传入ensureCapacityInternal()方法,确保数组容量能容纳新元素
- 首先调用calculateCapacity()方法得到所需的最小数组容量
- 如果是通过无参函数创建,则最小容量 = 默认数组容量 和 所需最小容量的最大值
- 如果不是,则返回所需的最小数组容量
- 将所需最小数组容量传入ensureExplicitCapacity(),与当前数组的容量先比,如果大于的话,调用grow()方法进行扩容
- grow()方法
- 将原数组容量扩大1.5倍
- 如果还是小的话,则直接新容量赋值所需最小容量
- 如果新容量大于MAX_ARRAY_SIZE,调用hugeCapacity方法得到新容量
- 如果小于0,则抛异常
- 如果大于MAX_ARRAY_SIZE,直接赋值为Integer.MAX_VALUE;
- 最后通过Arrays.copyOf进行复制新数组
- grow()方法
- 首先调用calculateCapacity()方法得到所需的最小数组容量
- 将元素放入数组中
- 将当前元素数量+1作为所需最小容量参数传入ensureCapacityInternal()方法,确保数组容量能容纳新元素
(3)扩容源码分析
- add()方法
- 将指定的元素追加到列表的末尾
- 调用ensureCapacityInternal()方法,传入当前长度+1的参数,确保数组能容纳新加入的元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
- ensureCapacityInternal()方法
- 调用calculateCapacity()方法:得到所需的最小数组容量
- 将方法结果最小容量,传入ensureExplicitCapacity()方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
- calculateCapacity()方法
- 如果是空数组,则与最小容量取 传入参数和默认容量的最大值
- 作用是,如果是最小容量小于默认容量,则会创建一个默认容量大小的数组
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
- ensureExplicitCapacity()方法
- 传入最小容量,判断最小容量是不是大于当前数组的长度
- 如果大于则调用grow方法进行扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
- grow()方法
- 将原数组容量扩大1.5倍
- 如果还是小的话,则直接赋值最小容量
- 最小容量如果大于MAX_ARRAY_SIZE,调用hugeCapacity方法得到新容量
- 通过Arrays.copyOf进行复制新数组
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
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);
}
- hugeCapacity()方法
- 如果小于0,则抛异常
- 如果大于MAX_ARRAY_SIZE,直接赋值为Integer.MAX_VALUE;
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
3. 相关问题
如何实现ArrayList线程安全
- 使用Vector代替ArrayList
- 使用Collection.synchronizedList包装ArryList,操作包装后的list
- 使用CopyOnWriteArrayList代替ArrayList
- 使用ArrayList时,通过同步机制去控制ArrayList的读写