目录
简介
- 数组型链表,底层数据结构是数组
- RandomAccess 接口的实现类,表明这是随机访问类型,在有index的情况下,访问的复杂度为O(1),插入和删除复杂度比较高O(n)
- 不是线程安全的,效率肯定比线程安全的高,单线程情况下使用
- 源码分析没有特别说明,都是基于JDK1.8的
源码分析
1、一些重要的常量和变量
//默认的初始化容量为10
private static final int DEFAULT_CAPACITY = 10;
//空的数组对象 ,用于空实例的共享空数组实例
private static final Object[] EMPTY_ELEMENTDATA = {};
//和上面差不多,只是如果使用默认的构造方法,那么久使用这个数组对象
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//不参加序列化的数组对象,数组缓冲区,长度就是ArrayList的容量
transient Object[] elementData; // non-private to simplify nested class access
//modCount 用来记录 ArrayList 结构发生变化的次数。
//结构发生变化是指添加或者删除至少一个元素的所有操作,或者是调整内部数组的大小,仅仅只是设置元素的值不算结构发生变化
protected transient int modCount = 0;
2、一些重要的方法源码
2.1、初始化的三个方法
这里需要注意的是,如果预先知道数据的容量大小,那么就填写该容量大小,不然会使用默认的容量,当超过默认容量的时候,会触发扩容机制, 频繁的扩容会浪费资源。
/**
*用户自定义初始化容量的初始化方法
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
}
//如果容量为0 ,使用默认的初始化容量 ,也就是 10
else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
}
//容量 < 0 ,抛出异常
else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 默认初始化容量,10
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_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;
}
}
2.2、add()的方法
添加元素的时候先ensureCapacityInternal()方法来确保容量大小是否足够,如果新增的长度大于原有的,则发生扩容机制(grow()方法),扩容到原来的1.5倍
//添加单个元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
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);
}
/**
* 可分配的最大数组大小,这里还是预留了8个长度大小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 数组扩容
*/
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//扩容为原来的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果新容量还是比当前容量小,那么新容量 = 当前容量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//如果新容量比可分配的最大数组大小还大,那么调用hugeCapacity()方法
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 进行数组复制
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
//如果当前容量大于可分配的最大数组大小,那么设置为Integer.MAX_VALUE,否则设定为MAX_ARRAY_SIZE;
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
2.3、序列化
我当时很好奇,为什么ArrayList还单独写了序列化和反序列化的方法,既然这么写,肯定有些原因的。如果从性能上思考,ArrayList的容量是动态增加的,声明的时候容量过大,那么剩下的就初始化为null,如果全部序列化的话,难免会浪费空间,同时也增加了点性能消耗。所以这里他序列化,只序列化到size这个地方。
/**
* 序列化
*/
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
// 判断前后元素数量是否超出
int expectedModCount = modCount;
s.defaultWriteObject();
// 确定序列化大小
s.writeInt(size);
// 写入数据
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
/**
* 反序列化
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
//获取序列化的大小
s.defaultReadObject();
// Read in capacity
s.readInt(); // ignored
if (size > 0) {
// 根据大小而不是容量来分配数组
ensureCapacityInternal(size);
Object[] a = elementData;
// 数据读出
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}
2.4、remove()方法
调用 System.arraycopy() 将 index+1 后面的元素都复制到 index 位置上,该操作的时间复杂度为 O(N)
/**
*删除列表中指定位置的元素。
*将任何后续元素向左移动(从它们的元素中减去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;
}
/**
* 删除列表中指定元素,遍历,然后获取index,调用fastRemove(),最后还是根据index来进行删除
*/
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;
}
/*
* 私有删除方法,该方法跳过界限检查而不跳过
* 返回删除的值
*/
private void fastRemove(int index) {
modCount++;
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
}