记录一下ArrayList 源码学习过程, 如果有错，希望评论指出！
ArrayList ~ 源码学习:
初学的时候 只知道其中的方法怎么用，并不太了解其中的实现，所以呢，写篇记录一下学习过程。
目录
注意：System.arraycopy() 和 Arrays.copyOf() 【点击跳转】。
~ 简单说说：
1、ArrayList 底层是基于数组实现的，准确来说 是动态数组。
2、ArrayList 初始化的容量默认自动为10 ，有扩容机制（下文介绍会说到） ，新扩容的容量为 原始容量的1.5倍（基于位运算）。
3、ArrayList 是线程不安全的；基于数组的实现，进行查找元素性能高，但是删除和新增元素性能较低（需要移动数组中的元素）。
本文记录学习，错误的地方 还希望指评论出来，慢慢来，总会一步步变好的！！！
在整理完LinkedList 之后 ，会把关于ArrayList 、LinkedList 常见面试题更新到博客中.........
1、架构层次：
当进入ArrayList 源码 首先看到的就是 ：
// 继承 AbstractList<E>类,实现List<E>, RandomAccess, Cloneable, Serializable 接口
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
为什么ArrayList 要先继承Abstract<E>呢？然后实现List<E>接口？
增加，修改，删除，查看方法之外，ArayList 继承该类之后，除了通用的方法，可以实现自身特有的方法，提高了代码的复用性。
继续看： ArrayList 实现了 四个接口 （List<E>, RandomAccess, Cloneable, Serializable）
实现 List<E>：之前看文章说 是作者觉得会有用（具体的也不知道真假 哈哈哈）。
实现了 RandomAccess : 标记性接口，实现了该接口，遍历性能更高。
实现了 Cloneable：Object.clone()。
实现了 Serializable : 表名该类可以被序列化。
2、属性
private static final long serialVersionUID = 8683452581122892189L;
/**
* 初始化容量为10
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 当指定Arraylist 当前的容量if 为0 的时候，当前数组会返回该空数组
* ArrayList 底层实际上就是数组
* 空数组
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 默认返回的空数组。
* 和 EMPTY_ELEMENTDATA 进行区分
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 保存ArrayList 中元素的数组
*/
transient Object[] elementData;
/**
* ArrayList 集合实际的大小（包含的元素总个数）
*/
private int size;
3、构造方法
/**
* 构造方法 1： 指定初始ArrayList 容量
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
// 如果 指定的初始化容量 > 0 ,那创建初始容量大小为 initialCapacity 的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
// 如果 指定的初始容量为 0 ，那创建空数组 EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 构造方法 2（默认构造函数）： 初始化成默认的数组 容量为0 ；
* 但是当添加第一个元素时，容量则变为10.
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/*
* 构造方法 3： 传入一个Collection 集合
*/
public ArrayList(Collection<? extends E> c) {
// 使用toArray()转换成数组,数据存到elementData 中
elementData = c.toArray();
// 判断 该数组中的元素个数是否为 0
if ((size = elementData.length) != 0) {
// 判断 此时的调用toArray() 的数组是否为Object 类型，调用getClass() 获取数组的类型
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else {
// 如果 为0 ，则使用空数组 EMPTY_ELEMENTDATA
this.elementData = EMPTY_ELEMENTDATA;
}
}4、部分方法
4.1： add(E e)
首先先检查数组的容量，If 容量充足 可以直接添加元素 ；If 容量不充足，进行扩容 [ grow()方法，扩容为原来的1.5倍] ，扩容实现之后，调用Arrays.copyOf()方法将原有数组的元素复制到新数组中.
// 直接添加元素
// 先确定 list 的容量 size ，看看是否需要 size+1，进行添加元素
// 添加的元素 在末尾位置
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
/**
* ensureCapacityInternal(minCapacity)
*/
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 传入的参数 minCapacity 和默认的容量 DEFAULT_CAPACITY 进行比较 ，取较大值
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
* ensureExplicitCapacity(minCapacity) ：此方法 用来判断是否进行数组扩容
*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 如果最小的容量 要比数组的长度大，那么就需要进行扩容，grow()实现扩容
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
/**
* grow(minCapacity)：扩容机制，在ArrayList 中很很很重要方法之一！！！！！！
*/
// 最大数组大小
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
private void grow(int minCapacity) {
// oldCapacity 为已存入数组中的元素容量
int oldCapacity = elementData.length;
// newCapacity 为原始容量 oldCapacity 的1.5倍（位运算 右移一位）
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 扩容 如果新容量newCapacity < 最小容量 minCapacity , 那么 容量就扩充为 minCapacity
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 判断容量 是否超出定义的最大容量 MAX_ARRAY_SIZE
// 如果 newCapacity - MAX_ARRAY_SIZE > 0 ，则调用 hugeCapacity()方法
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 扩容完之后 ，调用Arrays.copyOf() 将原来数组元素 复制到新数组中
elementData = Arrays.copyOf(elementData, newCapacity);
}
/**
* hugeCapacity(minCapacity)
* 用来比较 传入的 minCapacity 和定义的最大容量 MAX_ARRAY_SIZE 进行比较
* 如果 minCapacity > MAX_ARRAY_SIZE 那么 newCapacity 为 Integer.MAX_VALUE
* 如果 minCapacity < MAX_ARRAY_SIZE 那么 newCapacity 为 MAX_ARRAY_SIZE
*/
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
// 三步运算
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
/**
* Arrays.copyOf() ：底层是使用arraycopy() 实现的
*/
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]>
newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
// arraycopy() 其实就是复制一份数组
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* arraycopy()
*/
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);4.2： add(int index,E element)
// 将元素 element 插入指定的位置 index
// 首先 检查是否已经越界
// 然后 确保容量是否充足
// 最后 在 index位置 ，插入 element
public void add(int index, E element) {
// 检查index 是否已经超出最大界限（下标）
rangeCheckForAdd(index);
// 确保数组的容量充足
ensureCapacityInternal(size + 1);
// elementData : 原始数组
// index :原始数组的起始位置
// elementData : 目标数组
// index +1 : 目标数组的起始位置
// size - index : 要复制的元素数
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
// 插入元素之后 size+1
size++;
}
/**
* rangeCheckForAdd(index) ：判断index 是否越界
**/
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* ensureCapacityInternal(minCapacity) ：同add(E element)讲述
**/
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
/**
* ensureExplicitCapacity(minCapacity) ：同add(E element)讲述
**/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
4.3： get(int index)
// 获取指定位置index 的元素
public E get(int index) {
// 校验index 是否越界
rangeCheck(index);
return elementData(index);
}
// rangeCheck(index)
// 校验 index 是否越界
private void rangeCheck(int index) {
if (index < 0 || index >= this.size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}4.4： set(int index,E element)
// 此方法 可描述为 修改
// 另指定位置 index的值为 element
public E set(int index, E element) {
// 校验index 是否越界
rangeCheck(index);
// 将此位置原始数据取出
E oldValue = elementData(index);
// 将新数据赋值到 index 位置
elementData[index] = element;
// 返回 原始数据
return oldValue;
}4.5： remove(int 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; // clear to let GC do its work
return oldValue;
}
// 删除数组中某个指定的元素(第一个出现)
// 如果数组中并没有该元素，则不会进行删除操作
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;
}
// fastmove()
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
}注意：System.arraycopy() 和 Arrays.copyOf() 【点击跳转】。
4.6： trimToSize()
// 修改当前 Arraylist的容量的大小
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}4.7： isEmpty()
// 判断当期ArrayList 中是否数据
// 有元素 则返回 true
// 没有元素 则返回 false
public boolean isEmpty() {
return size == 0;
}4.8： contains()
// 是否包含某个指定的元素
public boolean contains(Object o) {
return indexOf(o) >= 0;
}4.9： indexOf()
// ArrayList 中某个指定元素的第一次出现的索引值
// 如果不包含该元素 则 return -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;
}
4.10： lastIndexOf()
// 某个元素在ArrayList 中最后一次出现的索引
// 可以对比 indexOf() 一起理解
public int lastIndexOf(Object o) {
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;
}4.11： clear()
// 清空 循环遍历 均赋值为 null
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
4.12： addAll()
// 把一个集合的所有元素追加到另外一个集合的末尾
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
// 这个方法 上述已经介绍过！！！
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
// 从指定位置 index 开始 ，将一个集合的所有的元素插入进去
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
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;
}
4.13： grow() 扩容机制
// oldCapacity为旧容量，newCapacity为新容量,minCapacity 最小需求量
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
// 扩大为原来的1.5 倍
// 位运算 右移一位 运运算速度大于整除运算
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 得到最小需求量
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
// 如果 最小需求容量 > 最大容量 ,则调用 hugeCapacity() 得到新容量
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
// hugeCapacity() ：如果 minCapacity > MAX_ARRAY_SIZE 将 Integer.MAX_VALUE 作为新数组
// 容量大小; 若 minCapacity < MAX_ARRAY_SIZE ,将 MAX_ARRAY_SIZE
// 作为 新数组容量大小，即为 Integer.MAX_VALUE - 8
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
544
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
