ArrayList源码分析
1、成员变量
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final long serialVersionUID = 8683452581122892189L;
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;
// ....
}
serialVersionUID
:序列化用的,暂时不清楚DEFAULT_CAPACITY
:默认容量为10EMPTY_ELEMENTDATA
:空数组,有参构造函数为0时用的DEFAULTCAPACITY_EMPTY_ELEMENTDATA
:空数组,无参构造函数用的elementData
:ArrayList集合存放元素的位置size
:集合中元素占据的大小,注意不是elementData.legnth
2、构造方法
2.1、无参构造
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
方法说明:将elementData
设置为空数组
2.2、有参构造1
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);
}
}
参数说明:
initialCapacity
:arraylist容量初始值
方法说明:
如果初始值大于0,将elementData
设置为一个该长度的数组
如果为0,也是将elementData
设置为空数组
如果小于0抛出异常
2.3、有参构造2
public ArrayList(Collection<? extends E> c) {
this.elementData = c.toArray();
if ((size = elementData.length) != 0) {
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// replace with empty array.
this.elementData = EMPTY_ELEMENTDATA;
}
}
参数说明:
Collection<? extends E> c
: E
类型下的Collection
的实现类集合
方法说明:
如果该集合中元素不是Object[]
集合就转化为Object[]
集合
3、自动扩容
private Object[] grow(int minCapacity) {
int oldCapacity = elementData.length;
if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
int newCapacity =
ArraysSupport.newLength(oldCapacity,
minCapacity - oldCapacity,
oldCapacity >> 1
return elementData = Arrays.copyOf(elementData, newCapacity);
} else {
return elementData = new Object[
Math.max(DEFAULT_CAPACITY, minCapacity)];
}
}
private Object[] grow() {
return grow(size + 1);
}
ArrayList的扩容机制:
- 执行
add
方法 - 如果
size == elementData.length
会触发扩容机制,执行grow()
- 执行
grow(size + 1)
- 第2行:首先拿到原来的容量
- 第3行:如果不是第一次添加
- 设置新的容量为原来的1.5倍,并且将复制数组到新数组里面
- 第9行:如果是第一次添加
- 执行初始扩容,将
elementData
设置为初始值
- 执行初始扩容,将
4、增删改查
4.1、add
public boolean add(E e) { // 向最后添加元素
modCount++;
add(e, elementData, size); // 调用下面方法
return true;
}
private void add(E e, Object[] elementData, int s){ // 检查是否要扩容
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
public void add(int index, E element) { // 向指定位置添加元素
rangeCheckForAdd(index);
modCount++;
final int s;
Object[] elementData;
if ((s = size) == (elementData = this.elementData).length) {
//扩容
elementData = grow();
}
System.arraycopy(elementData, index,
elementData, index + 1,
s - index);
elementData[index] = element;
size = s + 1;
}
4.2、remove
public E remove(int index) { // 指定位置删除元素
// 检查索引是否不在范围
Objects.checkIndex(index, size);
// 新的指针指向elementData
final Object[] es = elementData;
@SuppressWarnings("unchecked")
E oldValue = (E) es[index];
// 进行删除操作
fastRemove(es, index);
// 返回删除的元素
return oldValue;
}
private void fastRemove(Object[] es, int i) {
modCount++;
final int newSize = size - 1; // newSize 原来size - 1
if (newSize > i) // 如果删除的不是最后一个元素
System.arraycopy(es, i + 1, es, i, newSize - i);
size = newSize;
// 这里不管删除的是不是最后一个元素,都将原数组最后一个置为null
// 如果是删除的最后一个, 上一个if不执行,提高效率
es[size] = null;
}
4.3、set
将指定索引的元素改为新的值, 返回老的值
public E set(int index, E element) {
Objects.checkIndex(index, size);
checkForComodification();
E oldValue = root.elementData(offset + index);
root.elementData[offset + index] = element;
return oldValue;
}
4.4、get
得到索引为index的元素
public E get(int index) {
Objects.checkIndex(index, size);
return elementData(index);
}
5、总结
- ArrayList底层实现是数组。
- 当使用无参数构造函数创建ArrayList对象时,ArrayList对象中的数组初始长度为0(是一个空数组)。
- ArrayList的扩容策略是每次都增加当前数组长度的一半(非固定分配)。
- ArrayList的扩容方式是直接创建一个新的数组,并将数据拷贝到新数组中。