深入浅出，挖掘 JDK 17 的 ArrayList 底层实现原理

深入浅出，挖掘 JDK 17 的 ArrayList 底层实现原理

深入浅出，挖掘 JDK 17 的 ArrayList 底层实现原理

文章目录

​​深入浅出，挖掘 JDK 17 的 ArrayList 底层实现原理​​

​​前言​​​​正文​​

​​添加元素​​​​获取、设置元素​​​​删除元素​​

​​总结​​

前言

今天就来好好聊聊​​ArrayList​​。

正文

ArrayList 是一个数组队列，相当于 动态数组。与Java中的数组相比，它的容量能动态增长。它继承于AbstractList，实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

和Vector不同，ArrayList中的操作不是线程安全的！所以，建议在单线程中才使用ArrayList，而在多线程中可以选择Vector或者CopyOnWriteArrayList。

​​ArrayList​​​相比​​HashMap​​来说就比较简单了，先来看看实现了哪些接口：

public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable{ //默认容量大小 private static final int DEFAULT_CAPACITY = 10;//指定ArrayList容量为0时返回该数组private static final Object[] EMPTY_ELEMENTDATA = {};//当没有指定ArrayList容量时返回该数组private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};//保存添加到ArrayList中的元素（ArrayList的底层其实就是一个数组）transient Object[] elementData; //ArrayList中元素数量private int size;.....}

从上面的源码我们可以提取出下面几个关键信息：

​​ArrayList​​​底层使用一个​​Object​​类型的数组来保存数据​​ArrayList​​默认大小为10

可以看到​​ArrayList​​​底层是使用一个数组​​elementData​​​来保存数据的，因此也被称为动态数组。值得注意的是用了​​elementData​​​用了​​transient​​修饰。

transient表示elementData无法被序列化，为什么要这么设置呢？

因为​​elementData​​​里面不是所有的元素都有数据，因为容量的问题，​​elementData​​​里面有一些元素是空的，这种是没有必要序列化的。​​​ArrayList​​​的序列化和反序列化依赖​​writeObject​​​和​​readObject​​方法来实现。可以避免序列化空的元素。

接下来我们从常用构造函数入手：

public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}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); }}

上面两个构造函数比较简单，就是给对数组做初始化，这里不再细说。

​​ArrayList​​还有一个构造函数：

public ArrayList(Collection c) { Object[] a = c.toArray(); if ((size = a.length) != 0) { if (c.getClass() == ArrayList.class) { elementData = a; } else { elementData = Arrays.copyOf(a, size, Object[].class); } } else { // replace with empty array. //如果传入的c长度为0，则替换成空数组 elementData = EMPTY_ELEMENTDATA; } }

首先调用​​toArray()​​​返回一个数组，因为不一定会返回​​Object​​​类型，所以需要判断一下类型，如果类型不同则调用​​Arrays.copyOf​​方法，我们来看看源码：

/* * 复制数组，并转型为指定类型 * original——>原数组 newLength——>要复制的长度 newType——>新类型 */public static T[] copyOf(U[] original, int newLength, Class newType) { //判断是否是Object类型 T[] copy = ((Object)newType == (Object)Object[].class)//（这里不加(Object)强转编译器无法通过） ? (T[]) new Object[newLength] : (T[]) Array.newInstance(newType.getComponentType(), newLength); //getComponentType()——>本地方法，返回数组内的元素类型，不是数组时，返回null //Array.newInstance——>创建一个类型与newType一样，长度为newLength的数组 System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));//截断数组 return copy;}

从注释也可以看出该方法可以复制数组，并转型为指定类型。

添加元素

接下来是一个比较核心的方法​​add​​

/*添加元素到集合中*/public boolean add(E e) { //判断ArrayList是否需要扩容 ensureCapacityInternal(size + 1); elementData[size++] = e; return true;}/*判断是否需要扩容——> minCapacity是集合需要的最小容量*/private void ensureCapacityInternal(int minCapacity) { ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));}/*返回添加元素后的容量大小*/private static int calculateCapacity(Object[] elementData, int minCapacity) { //首次添加元素时，返回 minCapacity > 10 ? minCapacity : 10 （首次可能使用addAll方法添加大量元素） if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { return Math.max(DEFAULT_CAPACITY, minCapacity); } return minCapacity;}/*判断是否需要扩容*/private void ensureExplicitCapacity(int minCapacity) { modCount++;//modCount是继承自AbstractList的变量，用来表示集合被修改的次数 if (minCapacity - elementData.length > 0) grow(minCapacity);}/*扩容*/private void grow(int minCapacity) { int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容为原来的1.5倍 if (newCapacity - minCapacity < 0)//如果扩容后还是小于最小容量，则设置minCapacity为容量大小 newCapacity = minCapacity; if (newCapacity - MAX_ARRAY_SIZE > 0)//MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8 newCapacity = hugeCapacity(minCapacity); //调用Arrays.copyOf生成新数组 elementData = Arrays.copyOf(elementData, newCapacity);}private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;}

到目前为止，我们就可以知道add(E e)的基本实现了： 添加元素时，首先去检查一下数组的容量是否足够，如果不够则扩容到原来的1.5倍 扩容后，如果容量还是小于minCapacity，就将容量扩充为minCapacity，最后调用​​​Arrays.copyOf(elementData, newCapacity)​​方法生成新的数组。

获取、设置元素

下面看看​​get​​​和​​set​​方法：

/* * 获取index索引对象 */public E get(int index) { rangeCheck(index);//参数校验 return elementData(index);}E elementData(int index) { return (E) elementData[index];}/* * 设置index索引对象 */public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue;}private void rangeCheck(int index) { if (index >= size) throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}

两个方法都比较简单，这里不再展开细说。

删除元素

接下来看一下​​ArrayList​​如何删除元素：

/* * 删除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; //设为null让JVM回收 return oldValue;//返回旧数据}

做个简单总结

计算出需要左移的个数后，使用​​System.arraycopy​​方法截断生成新数组删除元素后将最后一位设为​​null​​便于JVM回收

还有另外一个​​remove(Object o)​​方法：

/* * 删除给定Object对象 */public boolean remove(Object o) { if (o == null) {//删除null对象-->ArrayList可以存放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++;//修改次数+1 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}

这部分源码比较简单，就是遍历比较然后删除。值得注意的是​​ArrayList​​可以存null值，因为需要对null参数做额外处理。

注意：调用remove删除元素时不会减少容量，若希望减少容量则调用​​trimToSize()​​,比较简单，下面直接贴上源码：

/* * 修改数组尺寸 */public void trimToSize() { modCount++; if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); }}

最后再来介绍几个平时用的比较多的方法：

我们平开发也会经常使用​​contains​​方法来判断是否包含某个元素，下面看下是如何实现的：

/* * 判断集合中是否包含某元素 */public boolean contains(Object o) { return indexOf(o) >= 0;}

可以看到直接使用​​indexOf​​​来判断，和之前​​String​​源码比较类似，直接来看看代码：

/* * 返回指定元素第一次出现的位置（返回-1表示没有此元素） * lastIndexOf——>同理（其实就是从后向前遍历） */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;}

其实就是遍历依次比较，相等则返回下标。

总结

看完是不是觉得相比​​HashMap​​​来说​​ArrayList​​​的源码还是比较能看懂的，当然我们这里只列出了一些比较常用的方法，像​​ArrayList​​​其实还有一些​​Itr​​等内部类，其实就是我们平时用的迭代器，如果对这些感兴趣的小伙伴可以自己去研究一下。

如果这篇文章对您有所帮助，或者有所启发的话，求一键三连：点赞、转发、收藏，您的支持是我坚持写作最大的动力。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。