一、定义
public class ArrayList<E> extends AbstractList<E> implements RandomAccess, Cloneable, java.io.Serializable
ArrayList 是一个数组队列,相当于 动态数组。与Java中的数组相比,它的容量能动态增长。
它继承于AbstractList,实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。
ArrayList 继承了AbstractList,实现了List。它是一个数组队列,提供了相关的添加、删除、修改、遍历等功能。
ArrayList 实现了RandmoAccess接口,即提供了随机访问功能。RandmoAccess是java中用来被List实现,为List提供快速访问功能的。在ArrayList中,我们即可以通过元素的序号快速获取元素对象;这就是快速随机访问。稍后,我们会比较List的“快速随机访问”和“通过Iterator迭代器访问”的效率。
ArrayList 实现了Cloneable接口,即覆盖了函数clone(),能被克隆。
ArrayList 实现java.io.Serializable接口,这意味着ArrayList支持序列化,能通过序列化去传输。
和Vector不同,ArrayList中的操作不是线程安全的!所以,建议在单线程中才使用ArrayList,而在多线程中可以选择Vector或者CopyOnWriteArrayList。
二、属性
//序列化id
private static final long serialVersionUID = 8683452581122892189L;
//默认数组初始的容量
private static final int DEFAULT_CAPACITY = 10;
//空的对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认的空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//实际上真正保存数据的数组,从此出可以看出ArrayList使用Object数组来保存数据,transient表示不可序列化
transient Object[] elementData;
//数组实际包含元素的个数
private int size;
三、构造方法
ArrayList提供了三种方式的构造器。
1.带有容量initialCapacity的构造方法
源码解释:
/**
* 构造函数一
* 如果大于0,会在ArrayList内部构建一个长度为initalCapacity的数组
* 如果等于0,会将上述的静态EMPTY_ELEMENTDATA属性赋值给elementData,也不会产生新的数组。如果小于0,则抛出异常
* @param initialCapacity 初始数组的容量
*/
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);
}
}
2.不带参数的构造方法
源码解释:
/**
* 构造函数二:无参的构造函数
* 会将上述的静态的DEFAULTCAPACITY_EMPTY_ELEMENTDATA属性,赋值给elementData属性,
* 也即我们用这种方法构造ArrayList的时候,内存中不会生成新的实例化数组,而是引用一个静态的空数组。
*/
public ArrayList(){
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
3.带参数Collection的构造方法
源码解释:
参数c为一个Collection,Collection的实现类大概有以下几种常用类型:
- List:元素可以重复的容器
- Set: 元素不可重复的容器
- Queue:结构是一个队列,先进先出
/**
* 构造函数三:传递一个集合给ArrayList
* @param c Collection集合
*/
public ArrayList(Collection<? extends E> c){
//首先会将集合转换成数组赋值给elementData,toArray方法有可能得到的不是Object[]类型
elementData = c.toArray();
if ((size = elementData.length) != 0){
//判断转换后的elementData是否是Object[]类型
if (elementData.getClass() != Object[].class){
//如果不是Object[]类型,将它转换成Object[]类型
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
} else {
//等于0,则将elementData赋值为EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
}
}
四、方法
1.trimToSize()
说明:将ArrayList的容量设置为当前size的大小。首先需要明确一个概念,ArrayList的size就是ArrayList的元素个数,length是ArrayList申请的内容空间长度。ArrayList每次都会预申请多一点空间,以便添加元素的时候不需要每次都进行扩容操作,例如我们的元素个数是10个,它申请的内存空间必定会大于10,即length>size,而这个方法就是把ArrayList的内存空间设置为size,去除没有用到的null值空间。这也就是我们为什么每次在获取数据长度是都是调用list.size()而不是list.length()。
源码解释:首先modCount是从类 java.util.AbstractList 继承的字段,这个字段主要是为了防止在多线程操作的情况下,List发生结构性的变化,什么意思呢?就是防止一个线程正在迭代,另外一个线程进行对List进行remove操作,这样当我们迭代到最后一个元素时,很明显此时List的最后一个元素为空,那么这时modCount就会告诉迭代器,让其抛出异常 ConcurrentModificationException。
如果没有这一个变量,那么系统肯定会报异常ArrayIndexOutOfBoundsException,这样的异常显然不是应该出现的(这些运行时错误都是使用者的逻辑错误导致的,我们的JDK那么高端,不会出现使用错误,我们只抛出使用者造成的错误,而这个错误是设计者应该考虑的),为了避免出现这样的异常,定义了检查。
/**
* 本质上是将数组的尾部空余的空间删除掉形成新数组
* 新数组的length与size一致,节约空间
*/
public void trimToSize() {
//修改次数加1
modCount++;
//ArrayList的size就是ArrayList的元素个数,length是ArrayList申请的内容空间长度。
if (size < elementData.length){
//将elementData中空余的空间(包括null值)去除,例如:数组长度为10,其中只有前三个元素有值,其他为空,那么调用该方法之后,数组的长度变为3.
elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}
2.ensureCapacity()扩容
/**
* public方法,用户可以自己扩容,
* 确保当前数组的容量可以满足继续向数组中添加元素
* @param minCapacity 所需的最小容量
*/
public void ensureCapacity(int minCapacity){
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;
if (minCapacity > minExpand){
//扩容
ensureExplicitCapacity(minCapacity);
}
}
/**
* 私有方法,内部判断是否需要扩容
* @param minCapacity
*/
private void ensureCapacityInternal(int minCapacity){
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA){
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
* 判断是否需要扩容
* 如果需要就调用grow方法,如果不需要,什么也不做
* @param minCapacity
*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0){
//正在实行扩容的方法
grow(minCapacity);
}
//如果minCapacity小于elementData数组的长度,说明无需扩容,什么也不做
}
/**
* ArrayList的扩容,接收一个int类型参数,表示至少需要多少容量
* @param minCapacity 数组所需最小容量
*/
private void grow(int minCapacity) {
//得到目前的容量
int oldCapacity = elementData.length;
//oldCapacity>>1表示除2取整数,该式子最终表示意思为newCapacity大于为oldCapacity的1.5倍数
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 下面的if处理等价 newCapacity = Math.Max(newCapacity,minCapacity);
if (newCapacity - minCapacity < 0){
newCapacity = minCapacity;
}
// 判断newCapacity是否超过最大值
if (newCapacity - MAX_ARRAY_SIZE > 0){
newCapacity = hugeCapacity(minCapacity);
}
//执行Arrays.copyOf方法,传递原数组与新数组长度,由Arrays内部创建数组返回并赋给elementData
elementData = Arrays.copyOf(elementData, newCapacity);
}
/*
* 求出最大的容量值,首先判断minCapacity是否已经溢出了,溢出了就直接抛出OOM
* 否则就去判断minCapacity 是否大于 MAX_ARRAY_SIZE
* 大于返回 Integer.MAX_VALUE ,不大于 返回MAX_ARRAY_SIZE
*/
private static int hugeCapacity(int minCapacity){
if (minCapacity < 0){
throw new OutOfMemoryError();
}
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}
3.size()获取ArrayList的大小
//继承AbstractList所必须实装的方法,返回ArrayList的大小
@Override
public int size() {
return size;
}
4.isEmpty()判断数组是否为空
/**
* 判断数组是否为空
* @return
*/
public boolean isEmpty(){
return size == 0;
}
5.contains(Object o)判断是否包含对象o
/**
* 判断是否包含对象o
* @return
*/
public boolean contains(Object o){
//调用indexOf()方法得到下标,存在则下标>=0,不存在为-1,即只要比较下标和0的大小即可。
return indexOf(0) >= 0;
}
6.indexOf(Object o)获取o在ArrayList中的下标位置
/**
* 对象o在ArrayList中的下标位置,如果存在返回位置i,不存在返回-1
* @param o
* @return
*/
public int indexOf(Object o ){
//遍历ArrayList的大小,比较o和容器内的元素,若相等,则返回位置i,若遍历完都不相等,返回-1
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;
}
7.lastIndexOf(Object o)获取o在ArrayList中最后出现的下标位置
/**
* 对象o在ArrayList中的出现的最后一个位置,如果存在返回位置i,不存在返回-1
* @param o
* @return
*/
public int lastIndexOf(Object o){
//和indexOf方法处理逻辑一样,这里是倒序查找
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;
}
8.toArray()
/**
* 将ArrayList转换成数组
* @return
*/
public Object[] toArray(){
return Arrays.copyOf(elementData, size);
}
9.toArray(T[] a)
/**
* 如果传入数组的长度小于size,返回一个新的数组,大小为size,类型与传入数组相同。
* 所传入数组长度与size相等,则将elementData复制到传入数组中并返回传入的数组。
* 若传入数组长度大于size,除了复制elementData外,还将把返回数组的第size个元素置为空。
* @param a
* @param <T>
* @return
*/
public <T> T[] toArray(T[] a){
if (a.length < size){
return (T[])Arrays.copyOf(elementData, size, a.getClass());
}
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size){
a[size] = null;
}
return a;
}
10.get(int index)
/**
* 不需要检查index的快速访问元素,但是是包权限,只允许内部使用
* @param index
* @return
*/
@SuppressWarnings("unchecked")
E elementData(int index){
return (E)elementData[index];
}
/**
* 继承AbstractList所必须实装的方法
* 通过下标快速访问来返回元素
* @param index
* @return
*/
@Override
public E get(int index){
rangeCheck(index);
return elementData(index);
}
/**
* 测试index是否越界
* @param index
*/
private void rangeCheck(int index) {
// 如果下标超过ArrayList的数组长度
if (index >= size){
// 抛出IndexOutOfBoundsException异常
throw new IndexOutOfBoundsException((outOfBoundsMsg(index)));
}
}
/**
* 抛出IndexOutOfBoundsException异常的message
* @param index
* @return
*/
private java.lang.String outOfBoundsMsg(int index){
return "Index: " + index + ", Size: " + size;
}
11.set(int index, E element)
/**
* 设置index位置的元素值了element,返回该位置的之前的值
* @param index
* @param element
* @return
*/
public E set(int index, E element){
//先判断下标是否越界
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
12.add(E e)
/**
* 添加元素
* @param e
* @return
*/
public boolean add(E e){
//判断是否需要扩容
ensureCapacityInternal(size + 1);
elementData[size] = e;
return true;
}
13.add(int index, E element)
/**
* 添加元素,指定添加位置
* @param element
* @return
*/
public void add(int index, E element){
// 判断index是否越界
rangeCheckForAdd(index);
//判断是否需要扩容
ensureCapacityInternal(size + 1);
// 将elementData从index位置开始,复制到elementData的index+1开始的连续空间
System.arraycopy(elementData, index, elementData, index + 1, size - index);
// 在elementData的index位置赋值element
elementData[index] = element;
size++;
}
/**
* 判断index是否越界
* @param index
*/
private void rangeCheckForAdd(int index){
if (index > size || index < 0){
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
}
14.remove(int index)
/**
* 指定下标删除元素
* @param index
* @return
*/
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);
}
//清除最后一个元素的引用,让GC来清理内存空间,因为原来的元素以及被删除了
elementData[--size] = null;
return oldValue;
}
15.remove(Object o)
/**
* 删除指定元素
* @param o
* @return
*/
public boolean remove(Object o){
if (o == null) {//删除null元素
for (int index = 0; index < size; index++)//迭代ArrayList
if (elementData[index] == null) {//如果在size之前的位置有存在空元素
fastRemove(index);//则快速删除(所谓快速删除,就是不去做越界检查以及不返回结果,完全给本类自己使用的private方法)
return true;
}
} else {//删除非空元素,与删除null元素逻辑相同
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {//此处使用equals方法来进行比较,所以在使用remove(Object o)的时候,要考虑是否重写了equals方法
fastRemove(index);//fastRemove也是会移动数组的,如果有删除重复元素的时候,效率很低
return true;
}
}
return false;
}
/**
* 快速删除
* 不做index检查,不返回结果,只允许内部使用
* @param index
* @return
*/
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
}
16.clear()
/**
* 清除数组,所有元素置为null
*/
public void clear(){
modCount++;
for (int i = 0; i < size; i++){
elementData[i] = null;
}
size = 0;
}
17.addAll(Collection<? extends E> c)
/**
* 一次性add多个元素,接受参数为集合类型
* @param c
* @return
*/
public boolean addAll(Collection<? extends E> c){
// 将c转换为数组a
Object[] a = c.toArray();
// 获取a占的内存空间长度赋值给numNew
int numNew = a.length;
//扩容
ensureCapacityInternal(size + numNew);
//将a数组插入到elementData的size位置
System.arraycopy(c, 0, elementData, size, numNew);
// 将size增加numNew
size += numNew;
// 如果c为空,返回false,c不为空,返回true
return numNew != 0;
}
18.addAll(int index, Collection<? extends E> c)
/**
* 指定index位置插入多个元素,原来位置的元素依次向后移动
* index不能大于size,如果大于size会产生数组越界
* @param index
* @param c
* @return
*/
public boolean addAll(int index, Collection<? extends E> c){
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew);
int numMoved = size - numNew;
if (numMoved > 0){
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
}
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
19.removeRange(int fromIndex, int toIndex)
/**
* 范围删除,删除从fromIndex~toIndex,包含fromIndex,不包含toIndex
* @param fromIndex
* @param toIndex
*/
protected void removeRange(int fromIndex, int toIndex){
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);
int newSize = size - (toIndex - fromIndex);
for (int i = newSize; i < size; i ++){
elementData[i] = null;
}
size = newSize;
}
20.removeAll(Collection<?> c)
/**
* 一次性删除多个元素
* @param c
* @return
*/
public boolean removeAll(Collection<?> c){
//判断c是否为空,为空抛出异常
Objects.requireNonNull(c);
//批量删除
return batchRemove(c, false);
}
21.retainAll(Collection<?> c)
/**
* 保留当前容器与c的并集,并返回
* 和removeAll相反,仅保留c中所有的元素
* @param c
* @return
*/
public boolean retainAll(Collection<?> c){
//判断c是否为空,为空抛出异常
Objects.requireNonNull(c);
//批量删除,注意第二个参数是TRUE
return batchRemove(c, true);
}
22.batchRemove(Collection<?> c, boolean complement)
/**
* 私有方法,根据complement值,将ArrayList中包含c中元素的元素删除或者保留
* @param c
* @param complement
* @return
*/
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;//一个读的index,一个是写的index
boolean modified = false;
try {
for (; r < size; r++){
if (c.contains(elementData[r]) == complement){
elementData[w++] = elementData[r];
}
}
} finally {
// 防止抛出异常导致上面r的右移过程没完成
if (r != size){
// 将r未右移完成的位置的元素赋值给w右边位置的元素
System.arraycopy(elementData, r, elementData, w, size - r);
// 修改w值增加size-r
w += size - r;
}
// 如果有被覆盖掉的元素,则将w后面的元素都赋值为null ,方便gc回收
if (w != size){
for (int i = w; i < size; i++){
elementData[i] = null;
}
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
23.writeObject(java.io.ObjectOutputStream s)
/**
* 保存数组实例的状态到一个流(即它序列化)
* @param s
*/
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
// Write out element count, and any hidden stuff
int expectedModCount = modCount;
s.defaultWriteObject();
// Write out size as capacity for behavioural compatibility with clone()
s.writeInt(size);
// Write out all elements in the proper order.
for (int i = 0; i<size; i++){
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount){
throw new ConcurrentModificationException();
}
}
24.readObject(java.io.ObjectOutputStream s)
/**
* 从一个流中读出数组实例的状态
* @param s
* @throws java.io.IOException
* @throws ClassNotFoundException
*/
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException,ClassNotFoundException{
elementData = EMPTY_ELEMENTDATA;
s.defaultReadObject();
s.readInt();
if (size > 0){
ensureCapacityInternal(size);
Object[] a = elementData;
for(int i =0; i < size; i++){
a[i] = s.readObject();
}
}
}
内部类
1. (1)private class Itr implements Iterator<E>
2. (2)private class ListItr extends Itr implements ListIterator<E>
3. (3)private class SubList extends AbstractList<E> implements RandomAccess
4. (4)static final class ArrayListSpliterator<E> implements Spliterator<E>
总结:
- ArrayList自己实现了序列化和反序列化的方法,因为它自己实现了 private void writeObject(java.io.ObjectOutputStream s)和 private void readObject(java.io.ObjectInputStream s) 方法
- ArrayList基于数组方式实现,无容量的限制(会扩容)
- 添加元素时可能要扩容(所以最好预判一下),删除元素时不会减少容量(若希望减少容量,trimToSize()),删除元素时,将删除掉的位置元素置为null,下次gc就会回收这些元素所占的内存空间。
- 线程不安全
- add(int index, E element):添加元素到数组中指定位置的时候,需要将该位置及其后边所有的元素都整块向后复制一位
- get(int index):获取指定位置上的元素时,可以通过索引直接获取(O(1))
- remove(Object o)需要遍历数组
- remove(int index)不需要遍历数组,只需判断index是否符合条件即可,效率比remove(Object o)高
- contains(E)需要遍历数组
- 使用iterator遍历可能会引发多线程异常