前言
很久之前写过一篇无关 HashMap
的文章:一文看懂 HashMap,反应不错。原本手前面是想写篇文章来介绍ArrayList
,起初事件多就忘了,明天就来好好聊聊ArrayList
。
注释
ArrayList
相比 HashMap
来说就比较简单了,先来看看实现了哪些接口:
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
// 默认容量大小
private static final int DEFAULT_CAPACITY = 10;
// 指定 ArrayList 容量为 0 时返回该数组
private static final Object[] EMPTY_ELEMENTDATA = {};
// 当没有指定 ArrayList 容量时返回该数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 保留增加到 ArrayList 中的元素(ArrayList 的底层其实就是一个数组)transient Object[] elementData;
//ArrayList 中元素数量
private int size;
.....
}
从下面的源码咱们能够提取出上面几个要害信息:
ArrayList
底层应用一个Object
类型的数组来保留数据ArrayList
默认大小为 10
能够看到 ArrayList
底层是应用一个数组 elementData
来保留数据的,因而也被称为动静数组。值得注意的是用了 elementData
用了 transient
润饰。
transient 示意 elementData 无奈被序列化,为什么要这么设置呢?
因为
elementData
外面不是所有的元素都有数据,因为容量的问题,elementData
外面有一些元素是空的,这种是没有必要序列化的。ArrayList
的序列化和反序列化依赖writeObject
和readObject
办法来实现。能够防止序列化空的元素。
接下来咱们从罕用构造函数动手:
public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}
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);
}
}
下面两个构造函数比较简单,就是给对数组做初始化,这里不再细说。
ArrayList
还有一个构造函数:
public ArrayList(Collection<? extends E> c) {Object[] a = c.toArray();
if ((size = a.length) != 0) {if (c.getClass() == ArrayList.class) {elementData = a;} else {elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
// 如果传入的 c 长度为 0,则替换成空数组
elementData = EMPTY_ELEMENTDATA;
}
}
首先调用 toArray()
返回一个数组,因为不肯定会返回 Object
类型,所以须要判断一下类型,如果类型不同则调用 Arrays.copyOf
办法,咱们来看看源码:
/*
* 复制数组,并转型为指定类型
* original——> 原数组 newLength——> 要复制的长度 newType——> 新类型
*/
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
// 判断是否是 Object 类型
T[] copy = ((Object)newType == (Object)Object[].class)//(这里不加 (Object) 强转编译器无奈通过)? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
//getComponentType()——> 本地办法,返回数组内的元素类型,不是数组时,返回 null
//Array.newInstance——> 创立一个类型与 newType 一样,长度为 newLength 的数组
System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));// 截断数组
return copy;
}
从正文也能够看出该办法能够 复制数组,并转型为指定类型 ,之前的啃碎 JDK 源码(一):String 曾经对System.arraycopy
做了介绍,感兴趣的小伙伴能够去看看,这里不再重述。
增加元素
接下来是一个比拟外围的办法add
/* 增加元素到汇合中 */
public boolean add(E e) {
// 判断 ArrayList 是否须要扩容
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
/* 判断是否须要扩容——> minCapacity 是汇合须要的最小容量 */
private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/* 返回增加元素后的容量大小 */
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 首次增加元素时,返回 minCapacity > 10 ? minCapacity : 10(首次可能应用 addAll 办法增加大量元素)if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
/* 判断是否须要扩容 */
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//modCount 是继承自 AbstractList 的变量,用来示意汇合被批改的次数
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/* 扩容 */
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);// 扩容为原来的 1.5 倍
if (newCapacity - minCapacity < 0)// 如果扩容后还是小于最小容量,则设置 minCapacity 为容量大小
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
newCapacity = hugeCapacity(minCapacity);
// 调用 Arrays.copyOf 生成新数组
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(E e)的根本实现了:
增加元素时,首先去检查一下数组的容量是否足够,如果不够则扩容到原来的 1.5 倍
扩容后,如果容量还是小于 minCapacity,就将容量裁减为 minCapacity,最初调用 Arrays.copyOf(elementData, newCapacity)
办法生成新的数组。
获取、设置元素
上面看看 get
和set
办法:
/*
* 获取 index 索引对象
*/
public E get(int index) {rangeCheck(index);// 参数校验
return elementData(index);
}
E elementData(int index) {return (E) elementData[index];
}
/*
* 设置 index 索引对象
*/
public E set(int index, E element) {rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
private void rangeCheck(int index) {if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
两个办法都比较简单,这里不再开展细说。
删除元素
接下来看一下 ArrayList
如何删除元素:
/*
* 删除 index 索引对象
*/
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; // 设为 null 让 JVM 回收
return oldValue;// 返回旧数据
}
做个简略总结
- 计算出须要左移的个数后,应用
System.arraycopy
办法截断生成新数组 - 删除元素后将最初一位设为
null
便于 JVM 回收
还有另外一个 remove(Object o)
办法:
/*
* 删除给定 Object 对象
*/
public boolean remove(Object o) {if (o == null) {// 删除 null 对象 -->ArrayList 能够寄存 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++;// 批改次数 +1
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
}
这部分源码比较简单,就是遍历比拟而后删除。值得注意的是 ArrayList
能够存 null 值,因为须要对 null 参数做额定解决。
留神:调用 remove 删除元素时不会缩小容量,若心愿缩小容量则调用trimToSize()
, 比较简单,上面间接贴上源码:
/*
* 批改数组尺寸
*/
public void trimToSize() {
modCount++;
if (size < elementData.length) {elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}
最初再来介绍几个平时用的比拟多的办法:
咱们平开发也会常常应用 contains
办法来判断是否蕴含某个元素,上面看下是如何实现的:
/*
* 判断汇合中是否蕴含某元素
*/
public boolean contains(Object o) {return indexOf(o) >= 0;
}
能够看到间接应用 indexOf
来判断,和之前 String
源码比拟相似,间接来看看代码:
/*
* 返回指定元素第一次呈现的地位(返回 - 1 示意没有此元素)* lastIndexOf——> 同理(其实就是从后向前遍历)*/
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;
}
其实就是遍历顺次比拟,相等则返回下标。
总结
看完是不是感觉相比 HashMap
来说 ArrayList
的源码还是比拟能看懂的,当然咱们这里只列出了一些比拟罕用的办法,像 ArrayList
其实还有一些 Itr
等外部类,其实就是咱们平时用的迭代器,如果对这些感兴趣的小伙伴能够本人去钻研一下。