本文主要分为两部分:
- ArrayList动态修改长度的秘密、集合size和数组length的区别
- ArrayList的数据结构(随机访问、插入、删除)
1. ArrayList动态修改长度的秘密、集合size和数组length的区别
//ArrayList构造函数的源码:(无参构造)
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
...
//数据容器
transient Object[] elementData;
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
//可以看出ArrayList其实是一个Object数组,初始化大小为0。
//数组的特性:其容量固定无法修改;数组中无法判断其中实际
//存有多少元素,length只是告诉我们数组的容量。
//那么ArrayList是怎么实现动态修改长度又是怎么知道数据大小的?
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
...
}
//既然动态变化长度,那么从添加和删除数据的方法来看吧。
//先看添加:
//ArrayList中有四个添加数据的方法:
//add(E e)添加数据到集合末尾;
//add(int index, E element)添加数据到指定位置;
//addAll(Collection<? extends E> c)添加集合到该集合末尾;
//addAll(int index, Collection<? extends E> c)添加集合到指定的位置。
//四个方法操作差不多,只需要了解其中一个就可以了,
//看一下ArrayList add(E e)方法的源码:
private static final int DEFAULT_CAPACITY = 10;
private static final int MAX_ARRAY_SIZE =
Integer.MAX_VALUE - 8;
private int size;
public boolean add(E e) {
//可以看出是在这个方法中确保了容器的大小,
//也就是动态改变容器大小
ensureCapacityInternal(size + 1);
//添加数据到尾部,在这里size++;
elementData[size++] = e;
return true;
}
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//确认容器大小,默认最小值为10。
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
private void ensureExplicitCapacity(int minCapacity) {
//记录修改次数
modCount++;
//判断是否需要扩充数组长度
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//容量增长一半
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//下面这个判断一般忽略
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
//到这就能看出动态增长实际上是new了一个新的数组,
//然后将原数组数据复制到新数组中,
//然后elementData指向新的数组。
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0)
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
//最后再返回看add()方法中,elementData[size++] = e;
//将数据赋值到了末尾,然后size+1。
//在ArrayList中数组容量最小为10,在达到临界值后,增长原数组长度的
//一半大小。size初始化为0,size+=添加的元素个数。
//集合size和数组length的区别:size<=length。
//常用的remove方法有:
//remove(Object o):删除指定的元素;
//remove(int index):删除指定下标的元素:
//removeAll(Collection<?> c):删除集合中的元素。
//主要看一下后两个删除方法吧,第一个第二个内部操作差不多。
public E remove(int index) {
//角标越界
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
//修改次数
modCount++;
E oldValue = (E) elementData[index];
//要复制的长度
int numMoved = size - index - 1;
if (numMoved > 0){
//arraycopy(Object src, int srcPos,
// Object dest, int destPos,
// int length);
//src:源数组;srcPos:源数组要复制的起始位置;
//dest:目的数组;destPos:数据放置目的数组的起始位置;
//length:要复制的长度。
//如:int[] ints={0,1,2,3,4,5,6};
//arraycopy(ints,0,ints,3,2);
//output:{0,1,2,0,1,5,6}
System.arraycopy(
elementData, index+1,
elementData, index,
numMoved);
}
//数据长度减一,最后一个数据制空。
//在这里size--
elementData[--size] = null;
return oldValue;
}
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
//去掉要删除的,然后整理数组
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
//为了兼容 c.contains()的异常。
if (r != size) {
//复制异常以后的数据到数组中
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
//制空重组后的数组中不需要的部分。
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;//在这里size等于重组后的数据长度
modified = true;
}
}
return modified;
}
//可以看出,在remove的方法中没有动态修改数组的长度。
//size-=删除的元素个数。
2. ArrayList的数据结构(插入、删除、随机访问)
//ArrayList基于顺序存储结构,适合随机访问元素,
//不适合在List中大量插入和移除元素。
public void add(int index, E element) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
ensureCapacityInternal(size + 1);
System.arraycopy(elementData, index,
elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
//插入方法中需要将index以后的数据元素往后移动,
//当数据量大的时候,这种插入操作无疑是耗时的。
public E remove(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
modCount++;
E oldValue = (E) elementData[index];
int numMoved = size - index - 1;
if (numMoved > 0){
System.arraycopy(
elementData, index+1,
elementData, index,
numMoved);
}
elementData[--size] = null;
return oldValue;
}
//删除操作需要将index以后的数据元素往后移动,
//和插入一样,当数据量大的时候,这种操作是比较耗时的。
public E get(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
return (E) elementData[index];
}
//随机访问get方法通过数组下标来返回数据。基于顺序存储结构,
//为一连串的数据存储,通过下标可以直接返回数组中数据。