ArrayList源码分析

时间 2021-02-18

标签 java git github 数组安全数据结构多线程 dom 函数性能栏目 Java 繁體版

原文原文链接

ArrayList简介：ArrayList 的底层是数组队列，至关于动态数组。与 Java 中的数组相比，它的容量能动态增加。在添加大量元素前，应用程序可使用ensureCapacity操做来增长 ArrayList 实例的容量。这能够减小递增式再分配的数量。java

它继承于 AbstractList，实现了 List, RandomAccess, Cloneable, java.io.Serializable 这些接口。git

在咱们学数据结构的时候就知道了线性表的顺序存储，插入删除元素的时间复杂度为O（n）,求表长以及增长元素，取第 i 元素的时间复杂度为O（1）github

ArrayList 继承了AbstractList，实现了List。它是一个数组队列，提供了相关的添加、删除、修改、遍历等功能。数组

ArrayList 实现了RandomAccess 接口，即提供了随机访问功能。RandomAccess 是 Java 中用来被 List 实现，为 List 提供快速访问功能的。在 ArrayList 中，咱们便可以经过元素的序号快速获取元素对象，这就是快速随机访问。ArrayList 实现了Cloneable 接口，即覆盖了函数 clone()，能被克隆。ArrayList 实现java.io.Serializable 接口，这意味着ArrayList支持序列化，能经过序列化去传输。安全

和Vector 不一样，ArrayList 中的操做不是线程安全的！因此，建议在单线程中才使用 ArrayList，而在多线程中能够选择 Vector 或者 CopyOnWriteArrayList数据结构

package java.util;多线程

import java.util.function.Consumer;dom

import java.util.function.Predicate;函数

import java.util.function.UnaryOperator;性能

public class ArrayList<E> extends AbstractList<E>

implements List<E>, RandomAccess, Cloneable, java.io.Serializable

{

private static final long serialVersionUID = 8683452581122892189L;

/**

* 默认初始容量大小

private static final int DEFAULT_CAPACITY = 10;

/**

* 空数组（用于空实例）。

private static final Object[] EMPTY_ELEMENTDATA = {};

//用于默认大小空实例的共享空数组实例。

//咱们把它从EMPTY_ELEMENTDATA数组中区分出来，以知道在添加第一个元素时容量须要增长多少。

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**

* 保存ArrayList数据的数组

transient Object[] elementData; // non-private to simplify nested class access

/**

* ArrayList 所包含的元素个数

private int size;

/**

* 带初始容量参数的构造函数。（用户本身指定容量）

public ArrayList(int initialCapacity) {

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;

}

/**

* 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

public ArrayList(Collection<? extends E> c) {

elementData = c.toArray();

//若是指定集合元素个数不为0

if ((size = elementData.length) != 0) {

// c.toArray 可能返回的不是Object类型的数组因此加上下面的语句用于判断，

//这里用到了反射里面的getClass()方法

if (elementData.getClass() != Object[].class)

elementData = Arrays.copyOf(elementData, size, Object[].class);

} else {

// 用空数组代替

this.elementData = EMPTY_ELEMENTDATA;

}

/**

* 修改这个ArrayList实例的容量是列表的当前大小。应用程序可使用此操做来最小化ArrayList实例的存储。

public void trimToSize() {

modCount++;

if (size < elementData.length) {

elementData = (size == 0)

? EMPTY_ELEMENTDATA

: Arrays.copyOf(elementData, size);

}

//下面是ArrayList的扩容机制

//ArrayList的扩容机制提升了性能，若是每次只扩充一个，

//那么频繁的插入会致使频繁的拷贝，下降性能，而ArrayList的扩容机制避免了这种状况。

/**

* 若有必要，增长此ArrayList实例的容量，以确保它至少能容纳元素的数量

* @param minCapacity 所需的最小容量

public void ensureCapacity(int minCapacity) {

int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)

// any size if not default element table

? 0

// larger than default for default empty table. It's already

// supposed to be at default size.

: DEFAULT_CAPACITY;

if (minCapacity > minExpand) {

ensureExplicitCapacity(minCapacity);

}

//获得最小扩容量

private void ensureCapacityInternal(int minCapacity) {

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

// 获取默认的容量和传入参数的较大值

minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

}

ensureExplicitCapacity(minCapacity);

}

//判断是否须要扩容

private void ensureExplicitCapacity(int minCapacity) {

modCount++;

// overflow-conscious code

if (minCapacity - elementData.length > 0)

//调用grow方法进行扩容，调用此方法表明已经开始扩容了

grow(minCapacity);

}

/**

* 要分配的最大数组大小

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**

* ArrayList扩容的核心方法。

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大于最大容量，则新容量则为ArrayList定义的最大容量，不然，新容量大小则为 minCapacity。

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) // overflow

throw new OutOfMemoryError();

return (minCapacity > MAX_ARRAY_SIZE) ?

Integer.MAX_VALUE :

MAX_ARRAY_SIZE;

}

/**

*返回此列表中的元素数。

public int size() {

return size;

}

/**

* 若是此列表不包含元素，则返回 true 。

public boolean isEmpty() {

//注意=和==的区别

return size == 0;

}

/**

* 若是此列表包含指定的元素，则返回true 。

public boolean contains(Object o) {

//indexOf()方法：返回此列表中指定元素的首次出现的索引，若是此列表不包含此元素，则为-1

return indexOf(o) >= 0;

}

/**

*返回此列表中指定元素的首次出现的索引，若是此列表不包含此元素，则为-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++)

//equals()方法比较

if (o.equals(elementData[i]))

return i;

}

return -1;

}

/**

* 返回此列表中指定元素的最后一次出现的索引，若是此列表不包含元素，则返回-1。.

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;

}

/**

* 返回此ArrayList实例的浅拷贝。（元素自己不被复制。）

public Object clone() {

try {

ArrayList<?> v = (ArrayList<?>) super.clone();

//Arrays.copyOf功能是实现数组的复制，返回复制后的数组。参数是被复制的数组和复制的长度

v.elementData = Arrays.copyOf(elementData, size);

v.modCount = 0;

return v;

} catch (CloneNotSupportedException e) {

// 这不该该发生，由于咱们是能够克隆的

throw new InternalError(e);

}

/**

*以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中全部元素的数组。

*返回的数组将是“安全的”，由于该列表不保留对它的引用。（换句话说，这个方法必须分配一个新的数组）。

*所以，调用者能够自由地修改返回的数组。此方法充当基于阵列和基于集合的API之间的桥梁。

public Object[] toArray() {

return Arrays.copyOf(elementData, size);

}

/**

* 以正确的顺序返回一个包含此列表中全部元素的数组（从第一个到最后一个元素）;

*返回的数组的运行时类型是指定数组的运行时类型。若是列表适合指定的数组，则返回其中。

*不然，将为指定数组的运行时类型和此列表的大小分配一个新数组。

*若是列表适用于指定的数组，其他空间（即数组的列表数量多于此元素），则紧跟在集合结束后的数组中的元素设置为null 。

*（这仅在调用者知道列表不包含任何空元素的状况下才能肯定列表的长度。）

@SuppressWarnings("unchecked")

public <T> T[] toArray(T[] a) {

if (a.length < size)

// 新建一个运行时类型的数组，可是ArrayList数组的内容

return (T[]) Arrays.copyOf(elementData, size, a.getClass());

//调用System提供的arraycopy()方法实现数组之间的复制

System.arraycopy(elementData, 0, a, 0, size);

if (a.length > size)

a[size] = null;

return a;

}

// Positional Access Operations

@SuppressWarnings("unchecked")

E elementData(int index) {

return (E) elementData[index];

}

/**

* 返回此列表中指定位置的元素。

public E get(int index) {

rangeCheck(index);

return elementData(index);

}

/**

* 用指定的元素替换此列表中指定位置的元素。

public E set(int index, E element) {

//对index进行界限检查

rangeCheck(index);

E oldValue = elementData(index);

elementData[index] = element;

//返回原来在这个位置的元素

return oldValue;

}

/**

* 将指定的元素追加到此列表的末尾。

public boolean add(E e) {

ensureCapacityInternal(size + 1); // Increments modCount!!

//这里看到ArrayList添加元素的实质就至关于为数组赋值

elementData[size++] = e;

return true;

}

/**

* 在此列表中的指定位置插入指定的元素。

*先调用 rangeCheckForAdd 对index进行界限检查；而后调用 ensureCapacityInternal 方法保证capacity足够大；

*再将从index开始以后的全部成员后移一个位置；将element插入index位置；最后size加1。

public void add(int index, E element) {

rangeCheckForAdd(index);

ensureCapacityInternal(size + 1); // Increments modCount!!

//arraycopy()这个实现数组之间复制的方法必定要看一下，下面就用到了arraycopy()方法实现数组本身复制本身

System.arraycopy(elementData, index, elementData, index + 1,

size - index);

elementData[index] = element;

size++;

}

/**

* 删除该列表中指定位置的元素。将任何后续元素移动到左侧（从其索引中减去一个元素）。

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;

}

/**

* 从列表中删除指定元素的第一个出现（若是存在）。若是列表不包含该元素，则它不会更改。

*返回true，若是此列表包含指定的元素

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;

}

* Private remove method that skips bounds checking and does not

* return the value removed.

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

}

/**

* 从列表中删除全部元素。

public void clear() {

modCount++;

// 把数组中全部的元素的值设为null

for (int i = 0; i < size; i++)

elementData[i] = null;

size = 0;

}

/**

* 按指定集合的Iterator返回的顺序将指定集合中的全部元素追加到此列表的末尾。

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;

}

/**

* 将指定集合中的全部元素插入到此列表中，从指定的位置开始。

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;

}

/**

* 今后列表中删除全部索引为fromIndex （含）和toIndex之间的元素。

*将任何后续元素移动到左侧（减小其索引）。

protected void removeRange(int fromIndex, int toIndex) {

modCount++;

int numMoved = size - 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;

}

size = newSize;

}

/**

* 检查给定的索引是否在范围内。

private void rangeCheck(int index) {

if (index >= size)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}

/**

* add和addAll使用的rangeCheck的一个版本

private void rangeCheckForAdd(int index) {

if (index > size || index < 0)

throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}

/**

* 返回IndexOutOfBoundsException细节信息

private String outOfBoundsMsg(int index) {

return "Index: "+index+", Size: "+size;

}

/**

* 今后列表中删除指定集合中包含的全部元素。

public boolean removeAll(Collection<?> c) {

Objects.requireNonNull(c);

//若是此列表被修改则返回true

return batchRemove(c, false);

}

/**

* 仅保留此列表中包含在指定集合中的元素。

*换句话说，今后列表中删除其中不包含在指定集合中的全部元素。

public boolean retainAll(Collection<?> c) {

Objects.requireNonNull(c);

return batchRemove(c, true);

}

/**

* 从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。

*指定的索引表示初始调用将返回的第一个元素为next 。初始调用previous将返回指定索引减1的元素。

*返回的列表迭代器是fail-fast 。

public ListIterator<E> listIterator(int index) {

if (index < 0 || index > size)

throw new IndexOutOfBoundsException("Index: "+index);

return new ListItr(index);

}

/**

*返回列表中的列表迭代器（按适当的顺序）。

*返回的列表迭代器是fail-fast 。

public ListIterator<E> listIterator() {

return new ListItr(0);

}

/**

*以正确的顺序返回该列表中的元素的迭代器。

*返回的迭代器是fail-fast 。

public Iterator<E> iterator() {

return new Itr();

}

在如上的源码中，咱们能够获得，在每次增长或者删除数据的时候都要进行位置或者容量的判断，扩容时默认扩展为1.5倍的容量（经过右移>>来扩展，这样的效率比/2的效率高），可是若是增长的数据比0.5倍的容量要多，则选择扩展所需大小的容量，咱们能够发现，不论是删除数组多余的空间仍是扩展空间，都频繁用到了数组的复制，System.arraycopy()和Arrays.copyOf()方法，看二者源代码能够发现copyOf()内部调用了System.arraycopy()方法区别: arraycopy()须要目标数组，将原数组拷贝到你本身定义的数组里，并且能够选择拷贝的起点和长度以及放入新数组中的位置; copyOf()是系统自动在内部新建一个数组，并返回该数组。

/**

     *以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中全部元素的数组。

     *返回的数组将是“安全的”，由于该列表不保留对它的引用。（换句话说，这个方法必须分配一个新的数组）。

     *所以，调用者能够自由地修改返回的数组。此方法充当基于阵列和基于集合的API之间的桥梁。

*/

    public Object[] toArray() {

    //elementData：要复制的数组；size：要复制的长度

        return Arrays.copyOf(elementData, size);

ArrayList的遍历方式：

ArrayList<Integer> arrayList = new ArrayList<Integer>();

//第一种：经过迭代器遍历

         System.out.print("经过迭代器遍历:");

         Iterator<Integer> it = arrayList.iterator();

         while(it.hasNext()){

             System.out.print(it.next() + " ");

//第二种：经过索引值遍历

         System.out.print("经过索引值遍历:");

         for(int i = 0; i < arrayList.size(); i++){

             System.out.print(arrayList.get(i) + " ");

//第三种：for循环遍历

         System.out.print("for循环遍历:");

         for(Integer number : arrayList){

             System.out.print(number + " ");