ArrayList源码分析
ArrayList简介
public class ArrayList<E> extends AbstractList<E> implements List<E>, 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。
ArrayList属性
// 默认容量 private static final int DEFAULT_CAPACITY = 10; // 一个空数组,当用户指定该 ArrayList 容量为 0 时,返回该空数组 private static final Object[] EMPTY_ELEMENTDATA = {}; /** 一个空数组实例 * - 当用户没有指定 ArrayList 的容量时(即调用无参构造函数),返回的是该数组==>刚创建一个 ArrayList 时,其内数据量为 0。 * - 当用户第一次添加元素时,该数组将会扩容,变成默认容量为 10(DEFAULT_CAPACITY) 的一个数组===>通过 ensureCapacityInternal() 实现 * 它与 EMPTY_ELEMENTDATA 的区别就是:该数组是默认返回的,而后者是在用户指定容量为 0 时返回 */ private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; /** * ArrayList基于数组实现,用该数组保存数据, ArrayList 的容量就是该数组的长度 * - 该值为 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时,当第一次添加元素进入 ArrayList 中时,数组将扩容值 DEFAULT_CAPACITY(10) */ transient Object[] elementData; /** * 当前数组长度,也即ArrayList实际存储的数据数量 */ private int size; // 数组最大长度 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
ArrayList构造函数
/** * 在创建ArrayList时,可指定ArrayList的初始容量,也即初始数组的长度. * 传入参数如果是大于0,则使用用户的参数初始化, * 如果用户传入的参数等于0,则将空数组实例 EMPTY_ELEMENTDATA 赋值给 数组引用变量elementData * 如果用户传入的参数小于0,则抛出异常 */ 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); } } // 空参构造函数 public ArrayList() { // DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为空数组实例 // 上文中创建了数组 Object[] elementData,在初始化一个ArrayList时, // 将该数组引用指向上文中已定义的空数组实例 DEFAULTCAPACITY_EMPTY_ELEMENTDATA // 此处,我们就可以看出,ArrayList 是基于数组实现的 this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; } /** * 创建一个包含collection的ArrayList * @param c 要放入 ArrayList 中的集合,其内元素将会全部添加到新建的 ArrayList 实例中 * @throws NullPointerException 当参数 c 为 null 时抛出异常 */ public ArrayList(Collection<? extends E> c) { // 将集合 c 转成 Object[] 数组 elementData = c.toArray(); if ((size = elementData.length) != 0) { // c.toArray might (incorrectly) not return Object[] (see 6260652) // 这句话意思是:c.toArray 可能不会返回 Object[],可以查看 java 官方编号为 6260652 的 bug if (elementData.getClass() != Object[].class) // 若 c.toArray() 返回的数组类型不是 Object[],则利用 Arrays.copyOf(); 来构造一个大小为 size 的 Object[] 数组 elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // replace with empty array. // 替换空数组 this.elementData = EMPTY_ELEMENTDATA; } }
add方法
1、add(E e)方法
add方法的执行逻辑如下:
1)确定 ArrayList 的容量大小,判断当前数组是否有足够容量存储传入的元素.
size为当前数组已使用的长度,通过调用ensureCapacityInternal(size + 1)方法来判断 ArrayList 是否需要扩容
如果当前数组已使用长度(size)加1后的大于当前的数组长度,则调用grow方法,增长数组,grow方法会将当前数组的长度变为原来容量的1.5倍。
2)确保新增的数据有地方存储之后,则将新元素添加到位于size的位置上。
/** *增加指定的元素到ArrayList的最后位置 * @param e 要添加的元素 * @return */ public boolean add(E e) { // 确定ArrayList的容量大小---严谨 // 注意:size + 1,保证资源空间不被浪费, // ☆☆☆按当前情况,保证要存多少个元素,就只分配多少空间资源 ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }
确保添加的元素有地方存储,当第一次添加元素的时候this.size+1 的值是1,所以第一次添加的时候会将当前elementData数组的长度变为10
private static int calculateCapacity(Object[] elementData, int minCapacity) { // 如果数组 elementData 与 数组 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 指向同一个地址,则返回DEFAULT_CAPACITY 和 minCapacity 中值较大的那一个 if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 返回 DEFAULT_CAPACITY 和 minCapacity 中值较大的那一个 // DEFAULT_CAPACITY 默认值为10,初始时 minCapacity 值为 size+1=1 return Math.max(DEFAULT_CAPACITY, minCapacity); } return minCapacity; }
/** * 私有方法:明确 ArrayList 的容量,提供给本类使用的方法 * - 用于内部优化,保证空间资源不被浪费:尤其在 add() 方法添加时起效 * @param minCapacity 指定的最小容量 */ private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); } private void ensureExplicitCapacity(int minCapacity) { modCount++; // 修改次数modCount 标识自增1 // overflow-conscious code // 判断是否需要扩容 // 当前所需的数组最小长度与数组的长度对比,如果大于0,则需要扩容。 if (minCapacity - elementData.length > 0) grow(minCapacity); } // 扩容方法 private void grow(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; // 数组容量扩大至原来的1.5倍 oldCapacity >> 1 即为 0.5 倍的 oldCapacity int newCapacity = oldCapacity + (oldCapacity >> 1); // 若 newCapacity 依旧小于 minCapacity if (newCapacity - minCapacity < 0) newCapacity = minCapacity; // 若 newCapacity 大于最大存储容量,则进行大容量分配 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); }
/** * 私有方法:大容量分配,最大分配 Integer.MAX_VALUE * @param minCapacity */ private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }
2、add(int index, E element)方法
这个方法其实和上面的add类似,该方法可以按照元素的位置,指定位置插入元素,具体的执行逻辑如下:
1)确保数插入的位置小于等于当前数组长度,并且不小于0,否则抛出异常
2)确保数组已使用长度(size)加1之后足够存下 下一个数据
3)修改次数(modCount)标识自增1,如果当前数组已使用长度(size)加1后的大于当前的数组长度,则调用grow方法,增长数组
4)grow方法会将当前数组的长度变为原来容量的1.5倍。
5)确保有足够的容量之后,使用System.arraycopy 将需要插入的位置(index)后面的元素统统往后移动一位。
6)将新的数据内容存放到数组的指定位置(index)上
public void add(int index, E element) { rangeCheckForAdd(index); //判断角标是否越界 ensureCapacityInternal(size + 1); // Increments modCount!! //第一个是要复制的数组,第二个是从要复制的数组的第几个开始, // 第三个是复制到那,四个是复制到的数组第几个开始,最后一个是复制长度 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; }
3、addAll
3.1 addAll(Collection<? extends E> c)
/** * 将一个集合的所有元素顺序添加(追加)到 lits 末尾 * - ArrayList 是线程不安全的。 * - 该方法没有加锁,当一个线程正在将 c 中的元素加入 list 中,但同时有另一个线程在更改 c 中的元素,可能会有问题 * @param c 要追加的集合 * @return <tt>true</tt> ? list 元素个数有改变时,成功:失败 * @throws NullPointerException 当 c 为 null 时 */ public boolean addAll(Collection<? extends E> c) { Object[] a = c.toArray(); // 将集合 c 转为 Object[] 数组 int numNew = a.length; ensureCapacityInternal(size + numNew); // 扩容 System.arraycopy(a, 0, elementData, size, numNew); size += numNew; // list 长度 return numNew != 0; }
3.2 addAll(int index, Collection<? extends E> c)
/** * 从 List 中指定位置开始插入指定集合的所有元素, * -list中原来位置的元素向后移 * - 并不会覆盖掉在 index 位置原有的值 * - 类似于 insert 操作,在 index 处插入 c.length 个元素(原来在此处的 n 个元素依次右移) * @param index 插入指定集合的索引 * @param c 要添加的集合 * @return ? list 元素个数有改变时,成功:失败 * @throws IndexOutOfBoundsException {@inheritDoc} * @throws NullPointerException if the specified collection is null */ 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 - index; if (numMoved > 0) System.arraycopy(elementData, index, elementData, index + numNew, numMoved); System.arraycopy(a, 0, elementData, index, numNew); size += numNew; return numNew != 0; } /** * 添加时检查索引是否越界 */ private void rangeCheckForAdd(int index) { if (index > size || index < 0) throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }
get方法 :用于获取 list 中指定位置上的元素
/** * 返回list中指定位置上的元素 */ public E get(int index) { rangeCheck(index); // 检查是否越界 return elementData(index); } /** * 检查索引 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]; }
set方法
/** * 确保set的位置小于当前数组的长度(size)并且大于0,获取指定位置(index)元素, * 然后放到oldValue存放,将需要设置的元素放到指定的位置(index)上,然后将原来位 * 置上的元素oldValue返回给用户。 */ public E set(int index, E element) { rangeCheck(index); // 检查 index 是否越界 E oldValue = elementData(index); // 获取 list 中索引为 index 的原先所存储的元素 elementData[index] = element; // 为 elementData[index] 重新赋值 return oldValue; // 返回原位置上的元素值 }
contains方法
// 判断 list 中是否包含元素o public boolean contains(Object o) { return indexOf(o) >= 0; } /** * 如果 list 集合中包含元素o,则返回第一次出现元素o的位置角标, * 如果 list 中不包含该元素则返回 -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; }
remove方法
1、根据索引remove
// 删除 list 中指定位置元素 public E remove(int index) { rangeCheck(index); // 判断 index 是否越界 modCount++; // 修改次数加1 E oldValue = elementData(index); // 获取指定位置(index)元素 int numMoved = size - index - 1; // 计算元素移动次数 if (numMoved > 0) System.arraycopy(elementData, index+1, elementData, index, numMoved); // 元素移动 elementData[--size] = null; // size为当前 list 中所存储的元素个数, --size表示最后一个元素的角标. // 当数组中某个位置元素删除后,则该位置后面的元素均需向前移动一个位置,这样 --size 这个位置的元素 // 向前移动一个位置后, elementData[--size]这个引用变量就失去了指向, 因此需要将其指向null, 然后由 // GC 垃圾回收起进行回收. return oldValue; }
2、根据对象remove
/** * 移除list中指定的第一个元素(符合条件索引最低的) * 如果list中不包含这个元素,则该list不会改变 * 如果包含这个元素,index 之后的所有元素依次左移一位 * @param o 该list中要被移除的元素 * @return */ 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; } /** * 快速删除第 index 个元素 * 和public E remove(int index)相比 * 私有方法,跳过检查,不返回被删除的值 * @param index 要删除的脚标 */ 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 }
3、根据角标范围remove
/** * 删除 list 中角标从 fromIndex(包括) 到 toIndex(不包括) 之间的所有元素 */ protected void removeRange(int fromIndex, int toIndex) { modCount++; // 修改次数加一 int numMoved = size - toIndex; // 角标 toIndex 后的所有元素左移次数 System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved); // 元素左移 // clear to let GC do its work int newSize = size - (toIndex-fromIndex); // 剩余元素个数 for (int i = newSize; i < size; i++) { elementData[i] = null; // 将 fromIndex 到 toIndex 之间的所有元素置空,等待垃圾回收器回收 } size = newSize; }
4、removeAll方法
/** * 移除list中指定集合包含的所有元素 * @param c 要从list中移除的指定集合 * @return {@code true} if this list changed as a result of the call * @throws ClassCastException 如果list中的一个元素的类和指定集合不兼容 * (<a href="Collection.html#optional-restrictions">optional</a>) * @throws NullPointerException 如果list中包含一个空元素,而指定集合中不允许有空元素 */ public boolean removeAll(Collection<?> c) { Objects.requireNonNull(c); // 判断集合 c 是否为空,为空的话抛出NullPointerException(), 不为空的话则会返回集合 c return batchRemove(c, false); } /** * 批处理移除 * @param c 要移除的集合 * @param complement 是否是补集 * 如果true:移除list中除了c集合中的所有元素 * 如果false:移除list中 c集合中的元素 */ private boolean batchRemove(Collection<?> c, boolean complement) { final Object[] elementData = this.elementData; int r = 0, w = 0; boolean modified = false; try { //遍历数组,并检查这个集合是否对应值,移动要保留的值到数组前面,w最后值为要保留的值得数量 //根据传入的 complement 值进行处理 //当 complement 为 true 时,即为保留:将相同元素移动到前段, //当 complement 为 false 时,即为不保留:将不同的元素移动到前段 for (; r < size; r++) if (c.contains(elementData[r]) == complement) elementData[w++] = elementData[r]; } finally { //最后 r=size 注意for循环中最后的r++ // w=保留元素的大小. //r!=size表示可能出错了, if (r != size) { System.arraycopy(elementData, r, elementData, w, size - r); w += size - r; } //如果w==size:表示全部元素都保留了,所以也就没有删除操作发生,所以会返回false;反之,返回true,并更改数组 //而 w!=size;即使try抛出异常,也能正常处理异常抛出前的操作,因为w始终要为保留的前半部分,数组也不会因此乱序 if (w != size) { // clear to let GC do its work for (int i = w; i < size; i++) elementData[i] = null; modCount += size - w; size = w; modified = true; } } return modified; }
clear方法
public void clear() { modCount++; // clear to let GC do its work for (int i = 0; i < size; i++) elementData[i] = null; size = 0; }
最后感谢:
(1)https://www.cnblogs.com/gxl1995/p/7534171344218b3784f1beb90d621337.html
(2)https://blog.csdn.net/fighterandknight/article/details/61240861
(3)https://www.cnblogs.com/skywang12345/p/3308556.html#a1