《JAVA1.8源码分析》:ArrayList
继承体系
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
ArrayList实现了AbstractList接口,并继承了list接口 ,同时实现了RandomAccess,Cloneable,Serializable接口,使其具有随机访问,复制和序列化的功能。
属性
//初始容量大小为10
1. private static final int DEFAULT_CAPACITY = 10;
//共享空常量数组
2. private static final Object[] EMPTY_ELEMENTDATA = {};
//共享空常量数组(与EMPTY_ELEMENTDATA的区别在于当第一个元素被加入进来的时候它知道如何扩张)
3. private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存储ArrayList中的元素(从这个可以看出,ArrayList是底层是借组于数组来实现的。)
4. transient Object[] elementData;
//存储的元素个数
5. private int size;
构造函数
ArrayList具有三个构造函数
//1.无参数构造函数(elementData数据直接复制为共享空常量数组)
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
构造一个初始容量为 10 的空列表。
即当我们不提供参数而new一个对象时,底层的数组就是直接用长度为10的空常量数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA进行实例化。
//2.指定容量作为参数的构造函数
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中情况进行了处理。当参数小于0时,抛异常。当参数等于0时,用空的常量数组对象EMPTY_ELEMENTDATA来初始化底层数组elementData。
//3.Collection作为参数的构造函数
//3.1 将集合转换为数组(c.toArray())并赋值给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;
}
}
从源码可以看到,将容器Collection转化为数组赋给数组elementData,还对Collection转化是否转化为了Object[]进行了检查判断。如果Collection为空,则就将空的常量数组对象EMPTY_ELEMENTDATA赋给了elementData;
add函数
//函数功能:将制定的元素加入到List的末尾。
public boolean add(E e) {
//添加修改次数以及判断是否需要扩张数组长度,
ensureCapacityInternal(size + 1); // Increments modCount!!
//插入数据,数据量+1
elementData[size++] = e;
return true;
}
//函数功能:将制定的元素加入到List的指定位置。
public void add(int index, E element) {
//位置有效性检查
rangeCheckForAdd(index);
//添加修改次数以及判断是否需要扩张数组长度,
ensureCapacityInternal(size + 1); // Increments modCount!!
//完成数组自身从index开始的所有元素拷贝到index+1开始且长度为size-index的位置上。
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//插入数据
elementData[index] = element;
//数据量加1
size++;
}
在增加数据之前都需要对数组长度进行判断,下面分析一下数据长度判断以及扩容的函数ensureCapacityInternal
private void ensureCapacityInternal(int minCapacity) {
//如果是刚构建的ArrayList,(数据长度则取10与minCapacity的最大值)
//调用无参构造相当于构造的一个长度为10的数组对象。
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
//数组长度不够,需要扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//ArrayList扩容函数
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//一般情况下是扩展到原来数组长度的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
/*下面两个if的作用为处理两种情况:
1)第一种情况为:如果newCapacity扩展的过小。则应该至少扩张到所需的空间大小minCapacity
2)第二种情况为:newCapacity扩张的过大,如果过大,则用Integer.MAX_VALUE来代替。*/
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:
//原来的数组中的元素复制扩展到大小为newCapacity的新数组中,并返回这个新数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
addAll函数
public boolean addAll(Collection<? extends E> c) {
//转为数组
Object[] a = c.toArray();
int numNew = a.length;
//判断是否扩容
ensureCapacityInternal(size + numNew); // Increments modCount
//复制集合数组到ArrayList数组中
System.arraycopy(a, 0, elementData, size, numNew);
//改变长度
size += numNew;
return numNew != 0;
}
public boolean addAll(int index, Collection<? extends E> c) {
//判断插入位置是否正常
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
//判断是否扩容
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
//先将Array数据从复制到后面
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
//复制集合数组到ArrayList数组中
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
remove函数
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
//数组从index开始往左移动一位
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//最后一个设置为null,便于回收
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
public boolean remove(Object o) {
if (o == null) {
//遍历寻找对象,然后删除(只删除第一个匹配的元素)
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
//和remove一样,只是少了位置校验
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
get函数
public E get(int index) {
//判断位置是否合法
rangeCheck(index);
//直接返回即可
return elementData(index);
}
set函数
public E set(int index, E element) {
//判断位置是否合法
rangeCheck(index);
E oldValue = elementData(index);
//更新数据
elementData[index] = element;
//返回老数据
return oldValue;
}
clear函数
public void clear() {
modCount++;
// clear to let GC do its work
//遍历依次置为null
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
小结
发现学了很多都忘记了,还是需要统一整理一下,然后做一下笔记。