ArrayList是基于数组实现的,是一个动态数组,其容量能自动增长,类似于C语言中的动态申请内存,动态增长内存。
ArrayList不是线程安全的,只能用在单线程环境下,多线程环境下可以考虑用Collections.synchronizedList(List l)函数返回一个线程安全的ArrayList类,也可以使用concurrent并发包下的CopyOnWriteArrayList类。
ArrayList实现了Serializable接口,因此它支持序列化,能够通过序列化传输,实现了RandomAccess接口,支持快速随机访问,实际上就是通过下标序号进行快速访问,实现了Cloneable接口,能被克隆。
构造方法
public ArrayList(int initialCapacity) {
// 传入的初始容量大于0,则会创建指定容量长度的数组
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
// 如果传入的初始容量为0,则指定为空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
//如果容量小于0,属于非法参数,直接抛出异常
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
// ArrayList无参构造函数
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 创建一个包含collection的ArrayList
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 {
// 替换为空数组
this.elementData = EMPTY_ELEMENTDATA;
}
}
增加元素
在增加元素之前一般会先判断是否需要扩容,如果满了就要进行扩容了。
//将指定的元素追加到此列表的末尾。
public boolean add(E e) {
//判断是否扩容
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
public void add(int index, E element) {
//判断元素要插入的位置是否越界
rangeCheckForAdd(index);
//判断是否扩容
ensureCapacityInternal(size + 1);
//将元素从最后一个开始每个元素往后移一位一直到index位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//将元素插入指定位置
elementData[index] = element;
//元素个数加一
size++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
数组扩容
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 如果数组为空数组,那么就取minCapacity和默认容量10的较大值
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
// 记录数组的修改次数
modCount++;
// 是否minCapacity超过当前数组的长度
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
//数组扩容,每次扩容是前一次的1.5倍
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//新数组为原数组的1.5倍
// 判断计算后的新数组容量是否满足要求的最小容量
// 如果不满足,则直接将新数组的容量设置为需要的容量
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:
elementData = Arrays.copyOf(elementData, newCapacity);
}
删除元素
分两种一种是指定元素一种是指定元素下标。
//通过下标删除元素
public E remove(int index) {
//判断元素是否越界
rangeCheck(index);
modCount++;
// 从数组中返回下标为index的元素
E oldValue = elementData(index);
//如果移除的元素不是最后一位则要对数组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;
}
//判断数组是否越界
private void rangeCheck(int index) {
if (index >= size) {
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
// 返回数组中下标为index的元素
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[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;
// 如果删除的不是最后一个元素
// 则将index后面的元素一次往前移动
if (numMoved > 0) {
System.arraycopy(elementData, index + 1, elementData, index, numMoved);
}
// 将数组空出的最后一个位置置位null,然后数组元素减1
elementData[--size] = null; // clear to let GC do its work
}
数组缩容
可以思考这种场景,一个ArrayList,刚开始初始容量为0,添加元素后,容量增大,但是后期数组元素在不断的删除元素,虽然数组中只剩下了5个元素,但是数组的长度还是数组中元素到达最大值的时候,这是极大地浪费,此时需要进行缩容,就是让底层数组调整为适合长度,最适合的长度就是刚好和元素数量个数相同。
ArrayList提供了trimToSize方法,就是进行缩容操作,将底层数组设置为刚好装下现有元素的长度。
public void trimToSize() {
modCount++;
// 如果数组中的元素数量小于数组的长度,才进行缩容
// 如果数组中没有元素,则将底层数组切换为一个空数组,否则就换为size大小的数组
if (size < elementData.length) {
elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}
查找数组元素
public E get(int index) {
// 数组越界检测
rangeCheck(index);
// 返回index下标的元素
return elementData(index);
}
// 判断数组是否越界
private void rangeCheck(int index) {
if (index >= size) {
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
// 返回数组中下标为index的元素
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}