ArrayList集合
ArrayList 的底层是数组队列，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加 ArrayList 实例的容量。这可以减少递增式再分配的数量。
ArrayList 继承于 AbstractList ，实现了 List, RandomAccess, Cloneable, java.io.Serializable 这些接口。
List : 表明它是一个列表，支持添加、删除、查找等操作，并且可以通过下标进行访问。
RandomAccess ：这是一个标志接口，表明实现这个接口的 List 集合是支持 快速随机访问 的。在 ArrayList 中，我们即可以通过元素的序号快速获取元素对象，这就是快速随机访问。
Cloneable ：表明它具有拷贝能力，可以进行深拷贝或浅拷贝操作。
Serializable : 表明它可以进行序列化操作，也就是可以将对象转换为字节流进行持久化存储或网络传输，非常方便。
ArrayList 和 Vector 的区别
ArrayList 是 List 的主要实现类，底层使用 Object[]存储，适用于频繁的查找工作，线程不安全 。Vector 是 List 的古老实现类，底层使用Object[] 存储，线程安全。
ArrayList 中可以存储任何类型的对象，包括 null 值。不过，不建议向ArrayList 中添加 null 值， null 值无意义，会让代码难以维护比如忘记做判空处理就会导致空指针异常。
核心代码模拟解读
- System.arrayCopy()
/**
* 复制数组
* @param src 源数组
* @param srcPos 源数组中的起始位置
* @param dest 目标数组
* @param destPos 目标数组中的起始位置
* @param length 要复制的数组元素的数量
*/
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
package com.netty.myb.list;
import java.util.*;
/**
* @program: java-study
* @description: ArrayList模拟
* @author: mengyb
* @create: 2025-07-15 14:30
**/
public class ArrayListDemo<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
/**
* 默认的容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* Shared empty array instance used for empty instances.
* 空的数组
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 存储元素的数组
*/
transient Object[] elementData; // non-private to simplify nested class access
/**
* 数组集合的大小Size
*/
private int size;
public static void main(String[] args) {
List<String> list = new ArrayList<>();
}
public ArrayListDemo(int initialCapacity) {
// 指定初始化的容量 则创建该容量的数组
if (initialCapacity > 0) {
// 创建一个初始的数组 Object[] elementData = new Object[initialCapacity];
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
// 初始化容量为0，则建立一个空的数组 Object[] elementData = {};
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayListDemo() {
// Object[] elementData = {};
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
public ArrayListDemo(Collection<? extends E> c) {
// 将一个集合转化为 数组 Object[] a = {1,1,1}
Object[] a = c.toArray();
// 数组的大小 不为0
if ((size = a.length) != 0) {
// 判断是否为ArrayList
if (c.getClass() == ArrayList.class) {
// Object[] elementData = a;
elementData = a;
} else {
// Object[] elementObject = {1,2,3}; 长度为size
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
// 如果数组为0 则创建一个空数组 Object[] elementData = {}
elementData = EMPTY_ELEMENTDATA;
}
}
@Override
public E get(int index) {
return null;
}
@Override
public int size() {
return size;
}
/**
* 浅拷贝
* @return
*/
public Object clone() {
try {
// 浅拷贝
ArrayListDemo<?> v = (ArrayListDemo<?>) super.clone();
// 实现数组的复制，返回复制后的数组
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
/**
* Arrays.copyOf(目标数组， 大小); 将Object[]数组拷贝出来
*/
public Object[] toArray() {
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());
// System.arraycopy(目标数组，从第几个开始，复制进新数组， 从新数组的第几个开始， 复制的长度为size)
// Object[] a = elementData;
System.arraycopy(elementData, 0, a, 0, size);
// 新数组的长度 大于 elementData的长度
if (a.length > size)
a[size] = null;
return a;
}
/**
* 获取数组 通过下标索引获取指定的元素
* @param index index of the element to return
* @return
*/
public E get(int index) {
// 检查 index 是否越界
rangeCheck(index);
// 从Object[] elementData数组中获取指定的下标值
return elementData(index);
}
/**
* 检查索引index 是否 超出Object[] elementData的长度
* @param index
*/
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 根据下标索引从数组中获取元素
* @param index
* @return
*/
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
/**
* 新增元素，在数组的最后添加元素
* @param e
* @return
*/
public boolean add(E e) {
// 扩容 1
ensureCapacityInternal(size + 1); // Increments modCount!!
// 将Object[] elementData 数组容量+1
elementData[size++] = e;
return true;
}
/**
* 在指定位置新增元素
* @param index 增加元素的索引
* @param element
*/
public void add(int index, E element) {
// 1 范围检测 判断是否越界
rangeCheckForAdd(index);
// 2 扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
// 3、将原数组复制到新数组中， 将elementData扩容后， index后面的元素 放到扩容后的index+1后
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
// 4、将扩容后，空闲出来的index索引元素 赋值为element
elementData[index] = element;
// 5、将统计容量的size+1
size++;
}
// 判断下标是否越界
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
/**
* 删除指定元素
* @param o 元素
* @return
*/
public boolean remove(Object o) {
if (o == null) {
// 找到 null 的元素索引
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
// 找到非null元素的索引
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
// 找到删除元素的下标索引
fastRemove(index);
return true;
}
}
return false;
}
/**
* 根据下标索引删除元素
* @param index 4
*/
private void fastRemove(int index) {
modCount++;
// 数组移动 8-4-1 = 5
int numMoved = size - index - 1;
if (numMoved > 0)
// 将index后的元素复制到 index-1后的位置，最后一个元素需要被删除
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
// 删除最后一个元素
elementData[--size] = null; // clear to let GC do its work
}
// 清空元素
public void clear() {
modCount++;
// clear to let GC do its work
// 将Object[] 的所有元素设置为null
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
/**
* 删除指定范围的元素
* @param fromIndex index of first element to be removed
* @param toIndex index after last element to be removed
*/
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
// 将范围以外的元素，赋值给formIndex开始的位置
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
// 新的数组大小Object[]
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
// 新的数组后的元素设置为null
elementData[i] = null;
}
size = newSize;
}
/**
* 扩容第一步
* @param minCapacity 在原来的size + 1
*/
private void ensureCapacityInternal(int minCapacity) {
// 开始扩容
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
/**
* 扩容 1.1
* @param elementData 原数组
* @param minCapacity 最小容量 size + 1
* @return
*/
private static int calculateCapacity(Object[] elementData, int minCapacity) {
// 判断当前数组Object[] elementData 是否是 {} 空的
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// elementData = {}; 在 默认容量10 与 现在的容量 进行比较 获取最大的那个值
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
// 返回现在的容量 size + 1
return minCapacity;
}
/**
* 扩容 1.2 步骤
* @param minCapacity DEFAULT_CAPACITY > size + 1 ? 10 : size+1
*/
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
// 判断是否扩容成功
if (minCapacity - elementData.length > 0)
// 扩容第二布
grow(minCapacity);
}
/**
* TODO 数组的最大长度为 Integer.MAX_VALUE-8
*/
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 扩容 2.1
* @param minCapacity DEFAULT_CAPACITY > size + 1 ? 10 : size+1
*/
private void grow(int minCapacity) {
// overflow-conscious code
// 原容量大小
int oldCapacity = elementData.length;
// 新容量 = 原容量 + 原容量/2;
int newCapacity = oldCapacity + (oldCapacity >> 1);
// 新容量 > size + 1;
if (newCapacity - minCapacity < 0)
// newCapacity = DEFAULT_CAPACITY > size + 1 ? 10 : size+1
newCapacity = 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);
}
/**
* 扩容 2.2 newCapacity新容量 超出了 最大值Integer.MAX_VALUE-8 的限制 后处理方案
* @param minCapacity DEFAULT_CAPACITY > size + 1 ? 10 : size+1
* @return
*/
private static int hugeCapacity(int minCapacity) {
//
if (minCapacity < 0) // overflow
// 内存溢出
throw new OutOfMemoryError();
// DEFAULT_CAPACITY > size + 1 ? 10 : size+1 > Integer.MAX_VALUE-8 : Integer.MAX_VALUE : Integer.MAX_VALUE-8
// 返回一个新的容量 要不然是 Integer的最大值，要不然返回数组的最大限制
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
}