之前有一次面试
问:你知道ArrayList底层是如何实现的吗?
答:底层是数组…
安静了大概2s后,面试官抬头疑惑的看向了我,我对他笑了笑。那是一段时间很长的沉默,空气中充满了尴尬。我知道希望我继续说下去,但我选择笑着面对这份沉默。
所以!了解底层原理也是很重要的,划重点,期末要考!
ArrayList介绍
ArrayList的底层是数组,相当于动态数组。与Java中的数组相比,它的容量能动态增长。
ArrayList
继承于AbstractList,实现了List,RandomAccess, Cloneable, java.io.Serializable 这些接口。
- 继承了AbstractList,实现List。它是一个数组队列,提供了相关的增,删,改,遍历等功能。
- 实现了RandomAccess接口。RandomAccess是一个标志接口,表示实现了这个接口的List集合是支持快速随机访问的。在ArrayList中,我们可以通过元素的序号快速获取元素。
- 实现了Cloneable接口。即覆盖了clone()方法,可以克隆。
- 实现了java.io.Serializable接口。ArrayList支持序列化,能通过序列化传输。
和Vector不同,ArrayList中的操作是非线程安全的。所以建议在单线程中使用ArrayList,在多线程中可以选择Vector或者CopyOnWriteArrayList。
ArrayList源码实现(JDK1.8)
扩容机制,初始化,增删等详细解释直接在源码以注释形式写出。
源码如下:
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 = {};
/**
* 用于默认大小空实例的共享空数组实例。
我们把它从EMPTY_ELEMENTDATA数组中区分出来,以知道在添加第一个元素时容量需要增加多少。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
保存ArrayList数据的数组
元素类型为Object,所以可以为任意类型数据
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* ArrayList 所包含的元素个数
*/
private int size;
/**
* 指定容量的空数组
*/
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);
}
}
/**
* 默认构造函数,构造一个空数组。
* 在第一次添加元素时,容量为10
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 构造一个指定元素集合的列表
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray(); //将集合中的元素放入elementData
if ((size = elementData.length) != 0) { //初始化size
// 如果c.toArray()的数据类型不是Object[],转换为Object[]
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}
/**
* 修改这个ArrayList的容量为当前大小。
*/
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//以下是ArrayList的扩容机制。
//每次扩容计算出扩容需要的最小容量。
/**
增加当前Arraylist实例的容量,如果必要,确保它至少能容纳元素的数量
@param minCapacity 所需的最小容量
*/
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
// any size if not default element table
? 0
// larger than default for default empty table. It's already
// supposed to be at default size.
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
//得到最小扩容量
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);
}
/**
* 要分配的最大数组大小
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 扩容核心方法
*/
private void grow(int minCapacity) {
// 考虑溢出的代码
int oldCapacity = elementData.length; //旧长度
//新长度=旧长度+旧长度/2,也就是说扩容1.5倍。位运算速度远远快于除法运算
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0) //如果新长度比最小值小 则新长度等于最小值
newCapacity = minCapacity;
//再检查新容量是否超出了ArrayList所定义的最大容量
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);
}
/*
比较minCapacity和 MAX_ARRAY_SIZE
如果minCapacity大于MAX_ARRAY_SIZE,则新容量则为Interger.MAX_VALUE,
否则,新容量大小则为 MAX_ARRAY_SIZE。
*/
private static int hugeCapacity(int minCapacity) {
// 检查minCapacity是否<0,如果是,证明超过最大值(正数溢出变为负数)。
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
/**
* 返回列表元素数量
*/
public int size() {
return size;
}
/**
* 判断是否==0,则返回true
*/
public boolean isEmpty() {
return size == 0;
}
/**
如果此列表包含指定的元素,则返回true 。
*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
/**
* 返回此列表中指定元素的首次出现的索引,如果此列表不包含此元素,则为-1
*/
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
/**
* 返回此列表中指定元素的最后一次出现的索引,如果此列表不包含元素,则返回-1。.
*/
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
/**
* 返回此ArrayList实例的浅拷贝。(数组内元素本身不被复制。)
*/
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
//Arrays.copyOf功能是实现数组的复制,返回复制后的数组。参数是被复制的数组和复制的长度
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
/**
以正确的顺序(从第一个到最后一个元素)返回一个包含此列表中所有元素的数组。
返回的数组将是“安全的”,因为该列表不保留对它的引用。
因此,调用者可以自由地修改返回的数组。
*/
public Object[] toArray() {
//elementData:要复制的数组;size:要复制的长度
return Arrays.copyOf(elementData, size);
}
/**
以正确的顺序返回一个包含此列表中所有元素的数组(从第一个到最后一个元素);
返回的数组的运行时类型是指定数组的运行时类型。 如果列表适合指定的数组,则返回其中。
否则,将为指定数组的运行时类型和此列表的大小分配一个新数组。
如果列表适用于指定的数组,其余空间(即数组的列表数量多于此元素),
则紧跟在集合结束后的数组中的元素设置为null 。
*/
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a's runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
/*
将指定的元素追加到此列表的末尾。
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
/**
在此列表中的指定位置插入指定的元素。
先调用 rangeCheckForAdd 对index进行界限检查;
然后调用 ensureCapacityInternal 方法保证capacity足够大;
再将从index开始之后的所有成员后移一个位置;将element插入index位置;最后size加1。
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
//arraycopy()方法实现数组自己复制自己:让index开始之后的所有成员后移一个位置
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
...
}
modCount
该字段定义在AbstractList中,表示list结构上被修改的次数。
结构上的修改指的是那些改变了list的长度大小或者使得遍历过程中产生不正确的结果的其它方式。
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
protected transient int modCount = 0;
}
该字段被Iterator以及ListIterator的实现类所使用,如果该值被意外更改,Iterator或者ListIterator 将抛出ConcurrentModificationException异常。这是jdk在面对迭代遍历的时候为了避免不确定性而采取的快速失败原则。
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
扩展:System.arraycopy()和Arrays.copyOf()方法
源码中多处使用了这两个方法,看两者源代码可以发现copyOf()
内部调用了System.arraycopy()
方法。
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);
- arraycopy()需要目标数组,将原数组拷贝到你自己定义的数组里,而且可以选择拷贝的起点和长度以及放入新数组中的位置
- copyOf()是系统自动在内部新建一个数组,并返回该数组。
ArrayList中的内部类
在ArrayList中,一共有4个内部类
private class Itr implements Iterator<E> {}
private class ListItr extends Itr implements ListIterator<E> {}
private class SubList extends AbstractList<E> implements RandomAccess {}
static final class ArrayListSpliterator<E> implements Spliterator<E> {}
Itr是实现了Iterator接口,同时重写了里面的hasNext(), next(), remove() 等方法;其中的ListItr 继承 Itr,实现了ListIterator接口,同时重写了hasPrevious(), nextIndex(), previousIndex(), previous(), set(E e), add(E e) 等方法,所以这也可以看出了 Iterator和ListIterator的区别: ListIterator在Iterator的基础上增加了添加对象,修改对象,逆向遍历等方法,这些是Iterator不能实现的。
总结
当需要向ArrayList中添加大量数据时,需要指定容量大小,扩容是一个非常消耗性能的操作,应避免ArrayList频繁扩容。
ArrayList底层是数组,通过索引直接得到元素,如add(E)和get(int),时间复杂度为O(1)。
当对指定位置进行插入或删除时,需要将对应索引位置后的所有元素进行移动,时间复杂读为O(n)。
ArrayList性能的好坏取决于操作位置距离数组末端的距离。