ArrayList源码分析
总览
- 底层：ArrayList底层是一个数组，能够扩容，正由于它扩容，因此它可以实现“动态”增加
- 容许null元素
- 时间复杂度：size、isEmpty、get、set、iterator和listIterator方法都以固定时间运行，时间复杂度为O(1)。add和remove方法须要O(n)时间。与用于LinkedList实现的常数因子相比，此实现的常数因子较低。
- 容量：ArrayList的容量能够自动增加。
- 是否同步：ArrayList不一样步的。
- 迭代器：ArrayList的iterator和listIterator方法返回的迭代器是fail-fast的。
定义
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io. Serializable
- ArrayList<E>：说明ArrayList支持泛型。
- extends AbstractList<E>：继承了AbstractList。AbstractList提供List接口的骨干实现，以最大限度地减小“随机访问”数据存储（如ArrayList）实现Llist所需的工做。
-
implementsjava
- List<E>：实现了List。实现了全部可选列表操做。
- RandomAccess：RandomAccess 是一个标志接口，代表实现这个这个接口的 List 集合是支持快速随机访问的。在 ArrayList 中，咱们便可以经过元素的序号快速获取元素对象，这就是快速随机访问。
- Cloneable：代表其能够调用clone()方法来返回实例的field-for-field拷贝。
- java.io.Serializable：代表该类具备序列化功能。
关键属性
/**
* 默认初始容量大小
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 指定该ArrayList容量为0时，返回该空数组。
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* 当调用无参构造方法，返回的是该数组。刚建立一个ArrayList 时，其内数据量为0。
* 它与EMPTY_ELEMENTDATA的区别就是：该数组是默认返回的，然后者是在用户指定容量为0时返回。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 保存ArrayList数据的数组
* 该值为DEFAULTCAPACITY_EMPTY_ELEMENTDATA 时，当第一次添加元素进入ArrayList中时，数组将扩容值DEFAULT_CAPACITY。
*/
transient Object[] elementData;
/**
* ArrayList 所包含的元素个数
*/
private int size;
问：elementData被标记为transient，那么它的序列化和反序列化是如何实现的呢？
答：ArrayList自定义了它的序列化和反序列化方式。详情请查看writeObject(java.io.ObjectOutputStream s)和readObject(java.io.ObjectOutputStream s)方法。git
构造方法
ArrayList提供了三种构造方法。github
- ArrayList(int initialCapacity)：构造一个指定容量为capacity的空ArrayList。
- ArrayList()：构造一个初始容量为 10 的空列表。
- ArrayList(Collection<? extends E> c)：构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。
/**
* 带初始容量参数的构造函数。（用户本身指定容量）
*/
public ArrayList(int initialCapacity) {
//初始容量大于0
if (initialCapacity > 0) {
//建立initialCapacity大小的数组
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
//建立空数组
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
/**
* 默认构造函数，DEFAULTCAPACITY_EMPTY_ELEMENTDATA 为0.初始化为10，
* 也就是说初始实际上是空数组 当添加第一个元素的时候数组容量才变成10
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。
* 若是指定的集合为null，throws NullPointerException。
*/
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
//若是指定集合元素个数不为0
if ((size = elementData.length) != 0) {
// c.toArray 可能返回的不是Object类型的数组因此加上下面的语句用于判断，
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
//【2】Arrays包含用来操做数组（好比排序和搜索）的各类方法。
//copyOf(U[] original, int newLength, Class<? extends T[]> newType)
// 复制指定的数组，截取或用 null 填充（若有必要），以使副本具备指定的长度。
} else {
this.elementData = EMPTY_ELEMENTDATA;
}
}
核心方法
get(int index)
步骤：segmentfault
- 检查角标
- 返回元素
/**
* 返回此列表中指定位置的元素。
*
* @param index 须要返回的元素的索引
* @return list中索引为index的元素
* @throws IndexOutOfBoundsException 若是索引超出size
*/
public E get(int index) {
//越界检查
rangeCheck(index);
return elementData(index);
}
/**
* 检查给定的索引是否在范围内。
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 返回IndexOutOfBoundsException细节信息
*/
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
/**
* 返回索引为index的元素
*/
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
add(E e)
步骤：数组
- 检查是否须要扩容
- 插入元素
整个扩容过程：安全
-
首先去检查一下数组的容量是否足够多线程
- 足够：直接添加
-
不足够：扩容dom
- 扩容到原来的1.5倍
- 第一次扩容后，若是容量仍是小于minCapacity，就将容量扩充为minCapacity。
/**
* 将指定的元素追加到此列表的末尾。
*/
public boolean add(E e) {
//确认list容量，若是不够，容量加1。注意：只加1，保证资源不被浪费
ensureCapacityInternal(size + 1);
//这里看到ArrayList添加元素的实质就至关于为数组赋值
elementData[size++] = e;
return true;
}
扩容ide
/**
* ArrayList的扩容机制
* ArrayList的扩容机制提升了性能，若是每次只扩充一个，
* 那么频繁的插入会致使频繁的拷贝，下降性能，而ArrayList的扩容机制避免了这种状况。
* 若有必要，增长此ArrayList实例的容量，以确保它至少能容纳元素的数量
* @param minCapacity 所需的最小容量
*/
public void ensureCapacity(int minCapacity) {
// 若是elementData等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA，最小扩容量为DEFAULT_CAPACITY，不然为0
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) ? 0 : DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
/**
* 数组容量检查，不够时则进行扩容。
*
* @param minCapacity 想要的最小容量
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 若elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA，
// 则取minCapacity为DEFAULT_CAPACITY和参数minCapacity之间的最大值
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//获得最小扩容量
private void ensureCapacityInternal(int minCapacity) {
// 获取默认的容量和传入参数的较大值
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//判断是否须要扩容
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 确保指定的最小容量 > 数组缓冲区当前的长度
if (minCapacity - elementData.length > 0)
//扩容
grow(minCapacity);
}
/**
* 要分配的最大数组大小
* 为何要减去8呢？
* 由于某些VM会在数组中保留一些头字，尝试分配这个最大存储容量，可能会致使array容量大于VM的limit，最终致使OutOfMemoryError。
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* ArrayList扩容的核心方法
*
* 第一次扩容，逻辑为newCapacity = oldCapacity + (oldCapacity >> 1);即在原有的容量基础上增长一半。
* 第一次扩容后，若是容量仍是小于minCapacity，就将容量扩充为minCapacity。
*/
private void grow(int minCapacity) {
// oldCapacity为旧容量，newCapacity为新容量
int oldCapacity = elementData.length;
//将oldCapacity 右移一位，其效果至关于oldCapacity /2，
//咱们知道位运算的速度远远快于整除运算，整句运算式的结果就是将新容量更新为旧容量的1.5倍，
int newCapacity = oldCapacity + (oldCapacity >> 1);
//而后检查新容量是否大于最小须要容量，若仍是小于最小须要容量，那么就把最小须要容量看成数组的新容量，
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//再检查新容量是否超出了ArrayList所定义的最大容量，
//若超出了，则调用hugeCapacity()来比较minCapacity和 MAX_ARRAY_SIZE，
//若是minCapacity大于MAX_ARRAY_SIZE，则新容量则为Interger.MAX_VALUE，不然，新容量大小则为 MAX_ARRAY_SIZE。
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);
}
//比较minCapacity和 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;
}
看完了代码，能够对扩容方法总结以下：函数
- 进行空间检查，决定是否进行扩容，以及肯定最少须要的容量
- 若是肯定扩容，就执行grow(int minCapacity)，minCapacity为最少须要的容量
- 第一次扩容，逻辑为newCapacity = oldCapacity + (oldCapacity >> 1);即在原有的容量基础上增长一半。
- 第一次扩容后，若是容量仍是小于minCapacity，就将容量扩充为minCapacity。
- 对扩容后的容量进行判断，若是大于容许的最大容量MAX_ARRAY_SIZE，则将容量再次调整为MAX_ARRAY_SIZE。至此扩容操做结束。
add(int index, E element)
步骤：
- 越界检查
- 空间检查，若是有须要进行扩容
- 插入元素
/**
* 在此列表中的指定位置插入指定的元素。
* 先调用 rangeCheckForAdd 对index进行界限检查；而后调用 ensureCapacityInternal 方法保证capacity足够大；
* 再将从index开始以后的全部成员后移一个位置；将element插入index位置；最后size加1。
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1);
//arraycopy()这个实现数组之间复制的方法必定要看一下，下面就用到了arraycopy()方法实现数组本身复制本身
//实现让index开始以后的全部元素后移一个位置:
//elementData:源数组;index:源数组中的起始位置;elementData：目标数组；index + 1：目标数组中的起始位置； size - index：要复制的数组元素的数量；
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
add(int index, E e)须要先对元素进行移动，而后完成插入操做，也就意味着该方法有着线性的时间复杂度，即O(n)
remove(int index)
步骤：
- 检查角标
- 删除元素
- 计算出须要移动的个数，将索引大于index的元素左移一位（左移后，该删除的元素就被覆盖了，至关于被删除了）
- 设置为null（size-1处），让Gc回收
/**
* 删除该列表中指定位置的元素。 将任何后续元素移动到左侧（从其索引中减去一个元素）。
*/
public E remove(int index) {
//检查索引是否越界
rangeCheck(index);
//结构性修改次数+1【1】
modCount++;
E oldValue = elementData(index);
// 删除指定元素后，须要左移的元素个数
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// size减一，而后将索引为size-1处的元素置为null。为了让GC起做用，必须显式的为最后一个位置赋null值
elementData[--size] = null;
//从列表中删除的元素
return oldValue;
}
注意：为了让GC起做用，必须显式的为最后一个位置赋null值。上面代码中若是不手动赋null值，除非对应的位置被其余元素覆盖，不然原来的对象就一直不会被回收。
set( int index, E element)
步骤：
- 检查角标
- 替代元素
- 返回旧值
/**
* 用指定的元素替换此列表中指定索引的元素。
*/
public E set(int index, E element) {
//对index进行界限检查
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
//返回原来在这个位置的元素
return oldValue;
}
细节：
- ArrayList是基于动态数组实现的，在增删时候，须要数组的拷贝复制。
- ArrayList的默认初始化容量是10，每次扩容时候增长原先容量的一半，也就是变为原来的1.5倍
- 删除元素时不会减小容量，若但愿减小容量则调用trimToSize()
- 它能存放null值。
- 和 Vector 不一样，ArrayList 中的操做不是线程安全的！因此，建议在单线程中才使用 ArrayList，而在多线程中能够选择 Vector 或者 CopyOnWriteArrayList。
移位运算符
简介：移位运算符就是在二进制的基础上对数字进行平移。按照平移的方向和填充数字的规则分为三种:<<(左移)、>>(带符号右移)和>>>(无符号右移)。
做用：对于大数据的2进制运算,位移运算符比那些普通运算符的运算要快不少,由于程序仅仅移动一下而已,不去计算,这样提升了效率,节省了资源
好比这里：int newCapacity = oldCapacity + (oldCapacity >> 1); 右移一位至关于除2，右移n位至关于除以 2 的 n 次方。这里 oldCapacity 明显右移了1位因此至关于oldCapacity /2。
另外须要注意的是：
- java 中的length 属性是针对数组说的，好比说你声明了一个数组，想知道这个数组的长度则用到了 length 这个属性.
- java 中的length()方法是针对字符串String说的，若是想看这个字符串的长度则用到 length()这个方法.
- java 中的size()方法是针对泛型集合说的，若是想看这个泛型有多少个元素，就调用此方法来查看!
内部类：
(1)private class Itr implements Iterator<E> (2)private class ListItr extends Itr implements ListIterator<E> (3)private class SubList extends AbstractList<E> implements RandomAccess (4)static final class ArrayListSpliterator<E> implements Spliterator<E>
- Itr是实现了Iterator接口，同时重写了里面的hasNext()，next()，remove()等方法；
- ListItr继承Itr，实现了ListIterator接口，同时重写了hasPrevious()，nextIndex()，previousIndex()，previous()，set(E e)，add(E e)等方法，
因此这也能够看出了 Iterator和ListIterator的区别：ListIterator在Iterator的基础上增长了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。
参考资料：
https://blog.csdn.net/panweiw...
https://segmentfault.com/a/11...
https://github.com/Snailclimb...
相关文章
- 1. ArrayList源码分析
- 2. ArrayList 源码分析
- 3. 源码分析|ArrayList
- 4. 源码分析——ArrayList
- 更多相关文章...
- • Docker 资源汇总 - Docker教程
- • Java操作Neo4j数据库（附带源码） - NoSQL教程
- • 互联网组织的未来：剖析GitHub员工的任性之源
- • Java Agent入门实战（二）-Instrumentation源码概述
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
