写在前面：博主是一位普普通通的19届双非软工在读生，平时最大的爱好就是听听歌，逛逛B站。博主很喜欢的一句话花开堪折直须折，莫待无花空折枝：博主的理解是头一次为人，就应该做自己想做的事，做自己不后悔的事，做自己以后不会留有遗憾的事，做自己觉得有意义的事，不浪费这大好的青春年华。博主写博客目的是记录所学到的知识并方便自己复习，在记录知识的同时获得部分浏览量，得到更多人的认可，满足小小的成就感，同时在写博客的途中结交更多志同道合的朋友，让自己在技术的路上并不孤单。

本文转载ArrayList(JDK1.8)源码解析

目录：

1.ArrayList概述
2.成员变量的源码解析(JDK1.8)
3.构造方法的源码解析(JDK1.8)
4.内部类源码解析(JDK1.8)
5.add()方法源码解析(JDK1.8)
6.数组扩容原理源码解析(JDK1.8)
7.大数据插入问题
8.remove()方法源码解析(JDK1.8)
9.get()方法源码解析(JDK1.8)
10.set()方法源码解析(JDK1.8)
11.indexOf()方法源码解析(JDK1.8)
12.contains()方法源码解析(JDK1.8)
13.toArray()方法源码解析(JDK1.8)
14.ArrayList集合的三种遍历方式
15.ArrayList和数组之间的转换
16.多线程场景下使用ArrayList
17.ArrayList的优缺点

1.ArrayList概述

1.1.ArrayList简介

java.util.ArrayList集合数据存储的结构是数组结构(它的底层原理其实就是一个Object数组)。元素增删慢，查找快，由于日常开发中使用最多的功能为查询数据、遍历数据，所以ArrayList是最常用的集合。

1.2.ArrayList特点：

1.它是基于数组实现的List类
2.可以动态地调整容量
3.有序的（元素输出顺序与输入顺序一致）
4.元素可以为 null
5.不同步，非线程安全，效率高
6.查询快，增删慢
7.用空间更小，对比 LinkedList，不用占用额外空间维护链表结构

2.成员变量的源码解析

// 序列号 private static final long serialVersionUID = 8683452581122892189L; // 数组初始容量为 10 private static final int DEFAULT_CAPACITY = 10;0 // 空对象数组 private static final Object[] EMPTY_ELEMENTDATA = {}; // 缺省空对象数组，如果使用默认构造方法创建对象内容是该值 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 底层数据结构，数组，当前对象存放的地方，当前对象不参与序列化 transient Object[] elementData; // 当前数组元素个数，默认为0 private int size; // 最大数组容量 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

注意看ArrayList 的 elementData 加上 transient 修饰可以这么解释：
再看一下 ArrayList 的定义：

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable

可以看到 ArrayList 实现了 Serializable 接口，这意味着 ArrayList 支持序列化。transient 的作用是说不希望 elementData 数组被序列化，重写了 writeObject 实现：

private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{*// Write out element count, and any hidden stuff*int expectedModCount = modCount;s.defaultWriteObject();*// Write out array length*s.writeInt(elementData.length);*// Write out all elements in the proper order.*for (int i=0; i<size; i++)s.writeObject(elementData[i]);if (modCount != expectedModCount) {throw new ConcurrentModificationException(); }

每次序列化时，先调用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素，然后遍历 elementData，只序列化已存入的元素，这样既加快了序列化的速度，又减小了序列化之后的文件大小。

3.构造方法的源码解析

//默认构造方法，初始为空数组。 //只有插入一条数据后才会扩展为10，而实际上默认是空的public ArrayList() {// 把空的对象数组赋给elementDatathis.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }//根据指定容量创建对象数组 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);} }/*** 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。*/ public ArrayList(Collection<? extends E> c) {//转换最主要的是toArray()，这在Collection中就定义了elementData = c.toArray();//toArray返回一个数组if ((size = elementData.length) != 0) {// c.toArray 有可能不返回一个 Object 数组if (elementData.getClass() != Object[].class)//因为所有的Object数组共用一个Class文件//使用 Arrays.copy 方法拷创建一个 Object 数组elementData = Arrays.copyOf(elementData, size, Object[].class);} else {// 替换为空数组this.elementData = EMPTY_ELEMENTDATA;} }

为了理解所有的Object数组共用一个Class文件，我们随机创建两个Object数组：

package untl; public class MyObject {public static void main(String[] args) {Object arr []=new Object[10];Object brr []=new Object[20];if(arr.getClass()==brr.getClass()){System.out.println("所有的Object数组共用一个Class文件");}elseSystem.out.println("不同的Object数组不一定共用一个Class文件");} } 运行结果： 所有的Object数组共用一个Class文件

4.内部类源码解析

(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>

我们只需要掌握两个迭代器就行

ArrayList有四个内部类，其中的Itr是实现了Iterator接口，同时重写了里面的hasNext()，next()， remove()等方法；其中的ListItr 继承 Itr，实现了ListIterator接口，同时重写了hasPrevious()， nextIndex()， previousIndex()，previous()， set(E e)，add(E e) 等方法，所以这也可以看出了 Iterator和ListIterator的区别：ListIterator在Iterator的基础上增加了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。

5.add()方法源码解析

//添加一个特定的元素到list的末尾 public boolean add(E e) {//先确保elementData数组的长度足够，size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个个数数组能否放得下，在这个方法中去判断数组长度是否够用ensureCapacityInternal(size + 1); // Increments modCount!!//在数据中正确的位置上放上元素e，并且size++elementData[size++] = e;return true; }//在指定位置添加一个元素 public void add(int index, E element) {rangeCheckForAdd(index);//先确保elementData数组的长度足够ensureCapacityInternal(size + 1); // Increments modCount!!//将数据整体向后移动一位，空出位置之后再插入，效率不太好System.arraycopy(elementData, index, elementData, index + 1,size - index);elementData[index] = element;size++; }// 校验插入位置是否合理 private void rangeCheckForAdd(int index) {//插入的位置肯定不能大于size 和小于0if (index > size || index < 0) //如果是，就报越界异常throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }//添加一个集合 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;//新数组有元素，就返回 truereturn 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 modCountint 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; }

我们主注意到其实元素的各种添加方式其实是依据System.arraycopy来实现

6.数组扩容原理源码解析

//确保内部容量够用 private void ensureCapacityInternal(int minCapacity) {ensureExplicitCapacity(calculateCapacity(elementData, minCapacity)); }//计算容量。判断初始化的elementData是不是空的数组,如果是空的话，返回默认容量10与minCapacity=size+1的较大值者。 private static int calculateCapacity(Object[] elementData, int minCapacity) {if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {return Math.max(DEFAULT_CAPACITY, minCapacity);}return minCapacity; }//确认实际的容量，这个方法就是真正的判断elementData是否够用 private void ensureExplicitCapacity(int minCapacity) {modCount++;//minCapacity如果大于了实际elementData的长度，那么就说明elementData数组的长度不够用，不够用那么就要增加elementData的length。这里有的小伙伴就会模糊minCapacity到底是什么呢，这里解释一下/*** 当我们要 add 进第1个元素到 ArrayList 时，elementData.length 为0 （因为还是一个空的 list），因为执行了 `ensureCapacityInternal()` 方法 ，所以 minCapacity 此时为10。此时，`minCapacity - elementData.length > 0 `成立，所以会进入 `grow(minCapacity)` 方法。* 当add第2个元素时，minCapacity 为2，此时e lementData.length(容量)在添加第一个元素后扩容成 10 了。此时，`minCapacity - elementData.length > 0 ` 不成立，所以不会进入 （执行）`grow(minCapacity)` 方法。* 添加第3、4···到第10个元素时，依然不会执行grow方法，数组容量都为10。* 直到添加第11个元素，minCapacity(为11)比elementData.length（为10）要大。进入grow方法进行扩容。*/// overflow-conscious codeif (minCapacity - elementData.length > 0)//ArrayList能自动扩展大小的关键方法就在这里了grow(minCapacity); }//扩容核心方法 private void grow(int minCapacity) {//将扩充前的elementData大小给oldCapacity// overflow-conscious codeint oldCapacity = elementData.length;//新容量newCapacity是1.5倍的旧容量oldCapacityint newCapacity = oldCapacity + (oldCapacity >> 1);//这句话就是适应于elementData就空数组的时候，length=0，那么oldCapacity=0，newCapacity=0，所以这个判断成立，在这里就是真正的初始化elementData的大小了，就是为10。if (newCapacity - minCapacity < 0)newCapacity = minCapacity;//如果newCapacity超过了最大的容量限制，就调用hugeCapacity，也就是将能给的最大值给newCapacityif (newCapacity - MAX_ARRAY_SIZE > 0)newCapacity = hugeCapacity(minCapacity);//新的容量大小已经确定好了，就copy数组，改变容量大小。// minCapacity is usually close to size, so this is a win:elementData = Arrays.copyOf(elementData, newCapacity); }//这个就是上面用到的方法，很简单，就是用来赋最大值。 private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflowthrow new OutOfMemoryError();//如果minCapacity都大于MAX_ARRAY_SIZE，那么就Integer.MAX_VALUE返回，反之将MAX_ARRAY_SIZE返回。因为maxCapacity是三倍的minCapacity，可能扩充的太大了，就用minCapacity来判断了。//Integer.MAX_VALUE:2147483647 MAX_ARRAY_SIZE：2147483639 也就是说最大也就能给到第一个数值。还是超过了这个限制，就要溢出了。相当于arraylist给了两层防护。return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE; }

至此，我们彻底明白了ArrayList的扩容机制了。首先创建一个空数组elementData，第一次插入数据时直接扩充至10，然后如果elementData的长度不足，就扩充至1.5倍，如果扩充完还不够，就使用需要的长度作为elementData的长度。

7.大数据问题

在遇到大量数据时还是会频繁的拷贝数据。那么如何缓解这种问题呢，
ArrayList为我们提供了两种可行的方案：

1.使用ArrayList(int initialCapacity)这个有参构造，在创建时就声明一个较大的大小，这样解决了频繁拷贝问题，但是需要我们提前预知数据的数量级，也会一直占有较大的内存。
2.除了添加数据时可以自动扩容外，我们还可以在插入前先进行一次扩容。只要提前预知数据的数量级，就可以在需要时直接一次扩充到位，与ArrayList(int initialCapacity)相比的好处在于不必一直占有较大内存，同时数据拷贝的次数也大大减少了。这个方法就是ensureCapacity(int minCapacity)，其内部就是调用了ensureCapacityInternal(int minCapacity)

举个例子看两者的效率：

public class EnsureCapacityTest {public static void main(String[] args) {ArrayList<Object> list = new ArrayList<Object>();final int N = 10000000;long startTime = System.currentTimeMillis();for (int i = 0; i < N; i++) {list.add(i);}long endTime = System.currentTimeMillis();System.out.println("使用ensureCapacity方法前：" + (endTime - startTime));list = new ArrayList<Object>();long startTime1 = System.currentTimeMillis();list.ensureCapacity(N);for (int i = 0; i < N; i++) {list.add(i);}long endTime1 = System.currentTimeMillis();System.out.println("使用ensureCapacity方法后：" + (endTime1 - startTime1));} } 运行结果： 使用ensureCapacity方法前：2700 使用ensureCapacity方法后：1054

通过运行结果，我们可以很明显的看出向 ArrayList 添加大量元素之前最好先使用ensureCapacity 方法，以减少增量重新分配的次数

8.remove()方法源码解析

//根据索引删除指定位置的元素 public E remove(int index) {//检查index的合理性rangeCheck(index);//这个作用很多，比如用来检测快速失败的一种标志。modCount++;//通过索引直接找到该元素E oldValue = elementData(index);//计算要移动的位数。int numMoved = size - index - 1;if (numMoved > 0)//移动元素，挨个往前移一位。System.arraycopy(elementData, index+1, elementData, index,numMoved);//将--size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。elementData[--size] = null; // clear to let GC do its work//返回删除的元素。return oldValue; }//从此列表中删除指定元素的第一个匹配项，如果存在，则删除。通过元素来删除该元素，就依次遍历，如果有这个元素，就将该元素的索引传给fastRemobe(index)，使用这个方法来删除该元素，fastRemove(index)方法的内部跟remove(index)的实现几乎一样，这里最主要是知道arrayList可以存储null值 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 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 }//删除或者保留指定集合中的元素 //用于两个方法，一个removeAll()：它只清除指定集合中的元素，retainAll()用来测试两个集合是否有交集。　 private boolean batchRemove(Collection<?> c, boolean complement) {//将原集合，记名为Afinal Object[] elementData = this.elementData;//r用来控制循环，w是记录有多少个交集int r = 0, w = 0;boolean modified = false;try {//遍历 ArrayList 集合for (; r < size; r++)//参数中的集合c一次检测集合A中的元素是否有if (c.contains(elementData[r]) == complement)//有的话，就给集合AelementData[w++] = elementData[r];} finally {//发生了异常，直接把 r 后面的复制到 w 后面if (r != size) {//将剩下的元素都赋值给集合ASystem.arraycopy(elementData, r,elementData, w,size - r);w += size - r;}if (w != size) {//这里有两个用途，在removeAll()时，w一直为0，就直接跟clear一样，全是为null。//retainAll()：没有一个交集返回true，有交集但不全交也返回true，而两个集合相等的时候，返回false，所以不能根据返回值来确认两个集合是否有交集，而是通过原集合的大小是否发生改变来判断，如果原集合中还有元素，则代表有交集，而元集合没有元素了，说明两个集合没有交集。// 清除多余的元素，clear to let GC do its workfor (int i = w; i < size; i++)elementData[i] = null;modCount += size - w;size = w;modified = true;}}return modified; }//保留公共的 public boolean retainAll(Collection<?> c) {Objects.requireNonNull(c);return batchRemove(c, true); }//将elementData中每个元素都赋值为null，等待垃圾回收将这个给回收掉 public void clear() {modCount++;//并没有直接使数组指向 null,而是逐个把元素置为空，下次使用时就不用重新 new 了for (int i = 0; i < size; i++)elementData[i] = null;size = 0; }

总结：根据索引删除指定位置的元素，此时会把指定下标到数组末尾的元素挨个向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC，可以作为小的技巧使用。

9.get()方法源码解析

public E get(int index) {// 检验索引是否合法rangeCheck(index);return elementData(index); }private void rangeCheck(int index) {if (index >= size)throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); }

说明：get函数会检查索引值是否合法（只检查是否大于size，而没有检查是否小于0），值得注意的是，在get函数中存在element函数，element函数用于返回具体的元素，具体函数如下：

E elementData(int index) {return (E) elementData[index]; }

说明：返回的值都经过了向下转型（Object -> E），这些是对我们应用程序屏蔽的小细节。

10.set()方法源码解析

//设定指定下标索引的元素值 public E set(int index, E element) {// 检验索引是否合法rangeCheck(index);// 旧值E oldValue = elementData(index);// 赋新值elementData[index] = element;// 返回旧值return oldValue; }

11.indexOf()方法源码解析

// 从首开始查找数组里面是否存在指定元素 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; }//返回列表中指定元素最后一次出现的索引，倒着遍历 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; }

说明：从头开始查找与指定元素相等的元素，需要注意的是可以查找null元素，意味着ArrayList中可以存放null元素的。与此函数对应的lastIndexOf，表示从尾部开始查找。

12.contains()方法源码解析

//判断是否含有某个元素 public boolean contains(Object o) {return indexOf(o) >= 0; }

13.toArray()方法源码解析

/**以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。 */ public Object[] toArray() {//elementData：要复制的数组；size：要复制的长度return Arrays.copyOf(elementData, size); }public <T> T[] toArray(T[] a) {//如果只是要把一部分转换成数组if (a.length < size)// Make a new array of a's runtime type, but my contents:return (T[]) Arrays.copyOf(elementData, size, a.getClass());//全部元素拷贝到 数组 aSystem.arraycopy(elementData, 0, a, 0, size);if (a.length > size)a[size] = null;return a; }

14.ArrayList三种遍历方式

14.1.第一种for循环

基于计数器。在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后停止

package untl; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class MyObject {public static void main(String[] args) {List<String> list=new ArrayList();Collections.addAll(list,"aaa","bbb","ccc","ddd");for (int i = 0; i <list.size() ; i++) {System.out.println(list.get(i));}} } 运行结果： aaa bbb ccc ddd

14.2.第二种foreach循环

foreach 内部也是采用了 Iterator 的方式实现，使用时不需要显式声明 Iterator 或计数器。优点是代码简洁，不易出错；缺点是只能做简单的遍历，不能在遍历过程中操作数据集合，例如删除、替换。

package untl; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class MyObject {public static void main(String[] args) {List<String> list=new ArrayList();Collections.addAll(list,"aaa","bbb","ccc","ddd");for (String str:list) {System.out.println(str);}} } aaa bbb ccc ddd

14.3.第三种迭代器Iterator

Iterator 是面向对象的一个设计模式，目的是屏蔽不同数据集合的特点，统一遍历集合的接口。Java 在 Collections 中支持了 Iterator 模式。

package untl; import java.util.ArrayList; import java.util.Collections; import java.util.Iterator; import java.util.List; public class MyObject {public static void main(String[] args) {List<String> list=new ArrayList();Collections.addAll(list,"aaa","bbb","ccc","ddd");for (Iterator<String> iterator=list.iterator();iterator.hasNext();){String str=iterator.next();System.out.println(str);}} } 运行结果： aaa bbb ccc ddd

15ArrayList与数组之间相互转换

数组转 List：使用 Arrays. asList(array) 进行转换。
List 转数组：使用 List 自带的 toArray() 方法。

例子：

package untl; import java.util.*; public class MyObject {public static void main(String[] args) {List<String> list1=new ArrayList<String>();Collections.addAll(list1,"aaa","bbb","ccc","ddd");Object arr[] = list1.toArray();//这里返回Object类型数组for (Object str:arr){System.out.println(str);}System.out.println("---------------------------------------------");List list2= Arrays.asList(arr);for (Iterator<String> iterator=list2.iterator();iterator.hasNext();){String str=iterator.next();System.out.println(str);}} } 运行结果： aaa bbb ccc ddd --------------------------------------------- aaa bbb ccc ddd

16.多线程场景下使用ArrayList

ArrayList 不是线程安全的，如果遇到多线程场景，可以通过 Collections 的 synchronizedList 方法将其转换成线程安全的容器后再使用。例如像下面这样：

List<String> synchronizedList = Collections.synchronizedList(list); synchronizedList.add("aaa"); synchronizedList.add("bbb"); for (int i = 0; i < synchronizedList.size(); i++) {System.out.println(synchronizedList.get(i)); }

17.ArrayList的优缺点

ArrayList优点如下：

1.ArrayList 底层以数组实现，是一种随机访问模式。ArrayList 实现了 RandomAccess 接口，因此查找的时候非常快。
2.ArrayList 在顺序添加一个元素的时候非常方便。

ArrayList 的缺点如下：

1.删除元素的时候，需要做一次元素复制操作。如果要复制的元素很多，那么就会比较 耗费性能。
2.插入元素的时候，也需要做一次元素复制操作，缺点同上。

总结

以上是生活随笔为你收集整理的ArrayList集合的使用和源码详细分析的全部内容，希望文章能够帮你解决所遇到的问题。

如果觉得生活随笔网站内容还不错，欢迎将生活随笔推荐给好友。