【深入理解Java集合框架 - 壹】 | ArrayListArrayList 是 Java 中最常用`的集合类之一，

前言

ArrayList是Java中最常用的集合类之一，其核心价值有如下4点：

高效的随机访问。
自动扩容机制。
自动调整数组大小。
灵活的增删改查及遍历操作。

操千曲而后晓声，观千剑而后识器。虐它千百遍方能通晓其真意。

一、概述

ArrayList 是 java.util 包中的一个类，它实现了 List 接口。基于动态数组实现，具备高效的随机访问能力和自动扩容机制，允许在运行时调整数组大小。

二、`ArrayList`的手写实现

根据上述定义及上图所示，手写一个简单的实现。

2.1、成员变量的定义

size：逻辑大小，控制数组内有效元素的个数。
capacity：容量，和JDK中的容量一致。
int[] array：静态数组，先使用简单的int类型实现。

private int size = 0;
private capacity = 10;
private int[] array = {};

2.2、添加及扩容操作(`核心`)

add(element)：向数组的末尾添加元素。
add(index,element)：向数组中指定位置添加元素。
- 1、边界检查。
- 2、容量检查。
- 3、添加数据。
  - index < size：涉及到数组中元素的移动，调用 System.arraycopy()进行操作。
  - index = size：向数组末尾添加元素。
- 4、更新size变量：增删过程中注意数组内元素数量的变化。。
grow()：
- size == 0：实例化数组及容量。
- size == capacity：
  - 1、进行扩容, 扩容为原来的1.5倍。
  - 2、创建新数组。
  - 3、调用System.arraycopy()将旧数组数据复制到新数组中。
  - 4、更新数组变量。

代码实现如下:

public void add(int element) {
    add(size, element);
}

public void add(int index, int element) {
    //1. 边界检查
    if (index < 0 || index > size) {
        throw new IndexOutOfBoundsException();
    }
    //2. 容量检查
    grow();
    //3. 添加数据
    if (index < size) {
        // 添加数据到指定位置, 移动数组中元素的位置
        System.arraycopy(array, index, array, index + 1, size - index);
    }
    array[index] = element;
    //更新成员变量, 增删过程中注意数组内元素数量的变化
    size++;
}

private void grow() {
    if (size == 0) {
        //1. 实例化数组及容量
        array = new int[capacity];
    } else if (size == capacity) {
        //2. 扩容为原来的1.5倍
        capacity += capacity >> 1;
        //3. 创建新数组
        int[] newArray = new int[capacity];
        //4.将旧数组元素复制到新数组中
        System.arraycopy(array, 0, newArray, 0, size);
        //5.更新数组变量
        array = newArray;
    }
}

2.3、删除及查询操作

remove(index): 根据索引删除元素。
- 1、边界检查。
- 2、记录删除的元素, 用于返回使用。
- 3、删除数据: 。
  - index < size：涉及到数组中元素的移动，调用 System.arraycopy()进行操作。
  - index = size：数组末尾删除元素。
- 4、更新size变量：增删过程中注意数组内元素数量的变化。
get(index): 根据索引查询元素。
- 边界检查。
- 访问元素。

代码实现如下:

public int remove(int index) {
    //1.边界检查
    if (index < 0 || index > size) {
        throw new IndexOutOfBoundsException();
    }
    //2.记录数据, 用于返回使用
    int removed = array[index];
    //3.非末尾删除时, 需要移动元素位置
    if (index < size) {
        System.arraycopy(array, index + 1, array, index, size - index - 1);
    }
    //更新成员变量, 增删过程中注意数组内元素数量的变化
    size++;
    return removed;
}

public int get(int index) {
    //1. 边界检查
    if (index < 0 || index > size) {
        throw new IndexOutOfBoundsException();
    }
    //2. 访问元素
    return array[index];
}

2.4、遍历操作

/**
 * 遍历方式1 函数式编程操作
 */
public void forEach(IntConsumer action) {
    for (int i = 0; i < size; i++) {
        action.accept(array[i]);
    }
}
/**
 * 遍历方式2 迭代器操作(增强for循环)
 */
@Override
public Iterator<Integer> iterator() {
    return new Iterator<Integer>() {
        int i = 0;

        @Override
        public boolean hasNext() {
            //1.判断是否还有下一个元素
            return i < size;
        }

        @Override
        public Integer next() {
            //2.返回当前元素, 并移动到下一个元素 注意i++操作
            return array[i++];
        }
    };
}

三、`ArrayList`的源码详解 (基于`JDK1.8`)

通过上述手动实现，我们对ArrayList有了一个初步的认知，接下来深入探索JDK中ArrayList源码的实现，继续加深理解程度。关于如何阅读源码，可从如下4个方面入手：

类的继承关系及接口实现。
成员变量。
构造函数。
核心方法。

图像表示：

3.1、类的继承关系及接口实现

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

知识以图片的形式进入大脑，记忆更为深刻。

3.1.1、Iterable

Java集合框架中最顶层的接口，提供了一种遍历集合中元素的统一方式，使得集合可以被for-each循环遍历，也称为增强for循环。

接口定义:

public interface Iterable<T> {
    Iterator<T> iterator();
}

主要方法:

iterator()：返回一个Iterator对象，用于遍历集合中的元素。

Iterator接口 ：

Iterator接口提供了遍历集合的方法，包括 hasNext() 和 next() 方法。

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove(); // 可选方法
}

hasNext()：判断是否还有下一个元素。
next()：返回当前元素，并移动到下一个元素。
remove()：删除刚刚返回的元素（可选方法）。

自定义实现方式在2.4中已实现，可仔细体会及品味一下。

3.1.2、Collection

Collection接口是所有集合类的根接口，提供了集合的基本操作方法，如添加、删除、查找和遍历元素。通过实现 Collection接口，不同的集合类可以共享相同的行为和方法。

public interface Collection<E> extends Iterable<E> {
    //1、添加元素
    boolean add(E e);
    boolean addAll(Collection<? extends E> c);
    //2、删除元素
    boolean remove(Object o);
    boolean removeAll(Collection<?> c);
    boolean retainAll(Collection<?> c);
    void clear();
    //3、查询操作
    boolean contains(Object o);
    boolean containsAll(Collection<?> c);
    boolean isEmpty();
    int size();
    boolean equals(Object o);
    int hashCode();
    //4、遍历操作
    Iterator<E> iterator();
    //5、转换操作
    Object[] toArray();
    <T> T[] toArray(T[] a);
}

3.1.3、List

List 接口继承自 Collection 接口，表示一个有序的集合（也称为序列）。List 中的元素可重复，并且每个元素有唯一的索引，索引从 0 开始。List 接口提供了许多与索引(index)有关的方法来操作和访问集合中的元素。

1、添加元素(非继承)：
- add(int index, E element)：在列表的指定位置插入元素。
- addAll(int index, Collection<? extends E> c)：将指定集合中的所有元素添加到列表的指定位置。
2、删除元素(非继承)：
- remove(int index)：移除列表中指定位置的元素，并返回被移除的元素。
3、替换元素(非继承)：
- set(int index, E element)：替换列表中指定位置的元素，并返回被替换的元素。
4、查询元素(非继承)：
- get(int index)：返回列表中指定位置的元素。
- indexOf(Object o)：返回列表中指定元素的首次出现的索引。
- lastIndexOf(Object o)：返回列表中指定元素的最后一次出现的索引。
5、遍历元素(非继承)：
- listIterator(int index)：返回从指定位置开始的列表迭代器。
6、子列表操作(非继承)：
- subList(int fromIndex, int toIndex)：返回列表的一部分视图，从 fromIndex（包括）到 toIndex（不包括）。

通过将 List 接口中的方法按功能进行分类，可以更清晰地理解和记忆这些方法。

3.1.4、AbstractCollection与AbstractList

AbstractCollection是Collection接口的一个抽象实现，提供了 Collection接口中大部分方法的默认实现。子类只需要实现 iterator() 和 size() 方法即可。该抽象类大大简化了集合类的实现。

AbstractList继承自AbstractCollection，并实现了List接口。它提供了一些List接口方法的默认实现，从而简化了具体List实现类的开发。子类只需要实现get(int index)和size()方法，其他方法可以根据需要重写。通过继承 AbstractList，可以快速实现一个功能完整的 List 类。

3.1.5、RandomAccess

RandomAccess是一个标记接口，无任何方法，其主要作用是标识那些支持快速随机访问的集合类。通过实现该接口可知哪些集合类支持高效的随机访问操作。

常见的实现类：ArrayList、Vector、Stack等。

3.1.6、Cloneable

Cloneable是一个标记接口，无任何方法，其主要作用是标识那些支持克隆操作的集合类。

克隆机制：在 Java 中，对象的克隆是通过调用 Object 类的 clone 方法实现的。Object 类的 clone 方法默认是浅拷贝，即只复制对象本身，而不递归复制对象中的引用类型成员。
避免CloneNotSupportedException：如果一个类实现了该接口，那么在调用 clone 方法时，不会抛出 CloneNotSupportedException 异常。如果没有实现该接口，调用 clone 方法会抛出这个异常。

3.1.7、Serializable

Serializable是一个标记接口，无任何方法，其主要作用是标识一个类的对象是否支持序列化操作。

序列化：是将对象的状态信息转换为字节流，以便存储到文件中或通过网络传输。
反序列化：是从字节流中恢复对象的状态信息，重建对象。

3.2、成员变量

/**
 * 初始化容量
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * 空数组实例
 */
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
 * 用于默认大小的空数组实例。
 * 将其与EMPTY_ELEMENTDATA区分开来，以了解添加第一个元素时要膨胀多少。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * 1、transient: 修饰意味着在 对象序列化时该字段不会被自动序列化。
 * 2、Object[]: 表示可以储存任何引用类型的元素。
 * 3、底层使用的依旧是静态数组的实现。
 */
transient Object[] elementData; 

/**
 * ArrayList的大小（包含的元素个数）
 */
private int size;

/**
 * 1、创建数组的最大容量
 * 2、一些虚拟机在数组中保留一些头部信息占用一定的空间。
 * 3、尝试分配较大的数组可能会导致OutOfMemoryError：请求的数组大小超过VM限制
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

3.3、构造函数

/**
 * 1、无参构造初始化了一个空列表; 
 * 2、在第1次添加元素时才会初始化容量为10的列表。
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

/**
 * 构造一个具有指定初始容量的空列表(当初始容量大于0时)。
 * 当初始容量等于0时, 初始化一个无容量的列表。
 * @param  initialCapacity 列表的初始容量
 * @throws IllegalArgumentException 如果指定的初始容量为负, 会抛一个非法参数的异常
 */
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);
    }
}

/**
 * 按照集合迭代器返回的顺序构造一个包含指定集合元素的列表。
 *
 * @param c 将其元素放入此列表的集合
 * @throws NullPointerException 如果指定的集合为null, 抛一个空指针异常
 */
public ArrayList(Collection<? extends E> 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.
        elementData = EMPTY_ELEMENTDATA;
    }
}

3.4、核心方法(`add`和`grow`)

第1次添加数据详细代码说明：

ArrayList<Integer> list = new ArrayList<>();
list.add(1);

/**
 * 1、添加一个指定的元素到列表的末尾
 */
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  
    elementData[size++] = e;
    return true;
}

/**
 * 2、确保列表的内部容量
 */
private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

/**
 * 3、计算容量
 */
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //使用默认构造时, elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //默认构造时, 返回最小容量与默认容量对比的最大值  
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

/**
 * 4、根据明确的容量是否进行扩容
 */
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    //若最小容量大于数组长度时, 进行扩容处理
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

/**
 * 5、增加容量，以确保它至少可以容纳由最小容量参数指定的元素数。
 */
private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    // 扩容为原数组的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    //将原数组拷贝新数组中并赋值给elementData
    elementData = Arrays.copyOf(elementData, newCapacity);
}

/**
 * 6、最终调用 System.arraycopy 进行数组拷贝。
 */
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

第2~10次添加数据：
第11次添加数据：

添加4步曲:

1、添加数据。
2、计算容量。
3、扩容为原数组的1.5倍(考察点)。
4、数组拷贝(Arrays.copyOf() -> System.arraycopy())(考察点)。

四、`ArrayList`的关键特性

4.1、动态数组：

内部使用一个数组 elementData 来存储元素。
当数组容量不足时，会自动扩容，通常将容量扩大到原来的 1.5 倍。

4.2、高效的随机访问：

由于内部使用数组，可以通过索引快速访问任意元素，时间复杂度为 O(1)。

4.3、自动扩容机制：

扩容条件：添加元素时若数组空间不足，会触发扩容。
扩容策略：扩容至旧容量的1.5倍，若新容量仍不满足需求，则直接设置为所需的最小容量。计算公式：newCapacity = oldCapacity + (oldCapacity >> 1)。
最大容量：Integer.MAX_VALUE - 8。
扩容过程：
- 计算容量。
- 根据新容量创建新数组。
- 复制原有元素到新数组中。
- 更新 elementData指向新数组。

4.4、灵活的增删改查及其他操作：

实现了 List 接口，提供了丰富的操作方法，如 add、remove、set、get、contains、size、isEmpty 等。

4.5、迭代器支持：

支持 Iterator 和 ListIterator，可以方便地遍历和修改列表中的元素。
迭代器实现是Fail-fast的，即在迭代过程中，如果有其他线程修改了集合的结构，将抛出ConcurrentModificationException异常。

4.6、泛型支持：

支持泛型，可以指定存储的元素类型，例如 ArrayList<String> 表示存储字符串的列表。

4.7、非线程安全：

非线程安全的，如需在多线程环境中使用，可以使用 Collections.synchronizedList方法将其包装成线程安全的列表。或者用CopyOnWriteArrayList。

五、`ArrayList`相关面试攻略

通过面试题，能进一步的促进我们对知识的深入理解以及掌握回答技巧，推荐以总~分的方式回答。下面列举几道常见面试题。

5.1、`ArrayList`的底层实现原理是什么?(`精通`)

总（开头总结）：

ArrayList 是 Java 中最常用的集合类之一，它基于动态数组实现，具有高效的随机访问能力和自动扩容机制。非末尾增删元素时会自动调整数组的大小。

分（详细展开）：

5.1.1、内部结构：

基于动态数组elementData存储元素。
初始容量为10。

5.1.2、初始化：

无参构造：创建一个初始容量为10的空列表。
容量构造：创建一个指定容量的空列表。
集合构造：创建一个指定集合元素`的列表。

5.1.3、自动扩容机制：

扩容条件：添加元素时若数组空间不足，会触发扩容。
扩容策略：扩容至旧容量的1.5倍，若新容量仍不满足需求，则直接设置为所需的最小容量。计算公式：newCapacity = oldCapacity + (oldCapacity >> 1)。 - 最大容量：Integer.MAX_VALUE - 8。
扩容过程：
- 计算容量。
- 根据新容量创建新数组。
- 复制原有元素到新数组中。
- 更新 elementData指向新数组。

5.1.4、添加元素：

添加元素致列表的末尾。
非末尾添加元素涉及数组调整，时间复杂度为O(n)。

5.1.5、删除元素：

非末尾删除元素涉及数组调整，时间复杂度为O(n)。

5.1.6、查找元素：

具备高效的随机访问能力，时间复杂度为 O(1)。

5.1.7、遍历：

支持迭代器遍历和删除元素。

5.1.8、非线程安全：

多线程下需要额外的同步措施。
在方法内使用，局部变量的线程安全较好。
通过Collections.synchronizedList(list)方法实现。
并发编程中使用CopyOnWriteArrayList来实现。

简记：

总：最常用、动态数组、随机访问、扩容机制、增删调整数组。
分：数据结构、初始化、扩容机制、增删查、遍历、非线程安全。

5.2、ArrayList和LinkedList的区别是什么?(`五星高频面试题`)

总（开头总结）：

ArrayList和LinkedList是Java中常用的两种列表实现类，它们在内部结构、内存占用、性能特点和适用场景上存在显著差异。ArrayList基于动态数组实现，而LinkedList基于双向链表实现。选择合适的列表实现类取决于具体的应用场景和性能需求。

分（详细展开）：

5.2.1、内部结构：

ArrayList：
- 基于动态数组实现。
- 初始容量为10。自动扩容至原有容量的1.5倍。
- 自动扩容机制。
LinkedList：
- 基于双向链表实现。
- 无固定容量。

5.2.2、内存开销：

ArrayList：
- 连续储存。
- 内存开销小。
LinkedList：
- 非连续储存。
- 内存开销大。

5.2.3、性能特点(`增删改查及迭代`)：

ArrayList：
- 支持高效的随机访问，时间复杂度为O(1)。
- 增删元素涉及数组调整，时间复杂度为O(n)。
- 迭代效率高，因为元素在内存中是连续存储的。
LinkedList：
- 不支持随机访问，改查元素需从头开始遍历，时间复杂度为O(n)。
- 增删元素性能较好，时间复杂度为O(1)。
- 迭代效率低，因为需要逐个节点访问。

5.2.4、适用场景：

ArrayList：
- 频繁的随机访问。
- 较少的增删操作。
LinkedList：
- 频繁的增删操作。
- 较少的随机访问。

5.2.5、线程安全：

Arraylist和LinkedList都不是线程安全的，如何保证线程安全?
在方法内使用，局部变量的线程安全较好。
通过Collections.synchronizedList(list)方法实现。
并发编程中使用CopyOnWriteArrayList来实现。

5.3、Arrayist list=new ArrayList(10)中的list扩容几次?

该题主要考察对源码的熟悉程度，具有一定的迷惑性。答案是未扩容，比较简单，这里就不详细叙述了。

回答要点1：简述初始容量及带容量的构造方法。
回答要求2：简述自动扩容机制(加分项)。

六、总结

ArrayList是基于动态数组实现的List，支持高效的随机访问。
非末尾增删元素因涉及数组调整效率较低。
自动扩容机制确保了数组容量的动态增长。
非线程安全，多线程环境下需要外部同步。
适合需要频繁访问元素且增删操作较少的场景。

码字不易，记得关注 + 点赞 + 收藏 + 评论

【深入理解Java集合框架 - 壹】 | ArrayList

前言