ArrayList简介

ArrayList是List接口的实现类，底层基于数组实现，容量可根据需要动态增加，相当于动态数组。ArrayList继承于AbstractList，并且还实现了Cloneable、Serializable、RandomAccess接口。

• List：表明是列表数据结构，可以通过下标对元素进行添加删除或查找。
• Serializable：表示可以进行序列化和反序列化操作，可以把对象与字节流相互转换。
• RandomAccess：有这个接口标记的List表示可以支持快速随机访问，即通过元素下标可以直接得到元素内容。
• Cloneable：表示支持拷贝，可以通过浅拷贝或深拷贝来复制对象的副本。

常用方法

public class ArrayListTest {
    public static void main(String[] args) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        arrayList.add(1); //添加元素
        arrayList.add(2);
        arrayList.add(3);
        arrayList.add(4);
        //在指定下标处插入元素
        arrayList.add(4, 5);
        //获取ArrayList大小
        System.out.println(arrayList.size()); //输出5
        //获取指定下标的元素
        System.out.println(arrayList.get(4)); //输出5
        //移除指定下标的元素
        arrayList.remove(0);
        //判断ArrayList内是否有指定元素
        System.out.println(arrayList.contains(5)); //输出true
        //修改指定下标的元素值
        arrayList.set(0, 9);
        System.out.println(arrayList.get(1)); //输出3
    }
}

ArrayList核心源码分析

类属性

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
	//序列号版本号
    @java.io.Serial
    private static final long serialVersionUID = 8683452581122892189L;

	//默认初始容量
    private static final int DEFAULT_CAPACITY = 10;

	//空数组，指定默认初始化容量为0时赋值给elementData，避免了重复创建空数组
    private static final Object[] EMPTY_ELEMENTDATA = {};

	//当调用无参构造方法时，赋值给elementData，主要用于在添加第一个元素前，标记该ArrayList是由无参构造器创建，便于将容量初始化为DEFAULT_CAPACITY，避免了重复创建空数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //实际存放元素的数组
    transient Object[] elementData; // non-private to simplify nested class access

    //ArrayList的元素个数
    private int size;
}

构造方法

//无参构造器，最开始创建的是空数组，当添加第一个元素时初始化容量为10。
public ArrayList() {
	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

//指定初始化容量，为0的话则创建空数组。
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<? 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;
	}
}

add

ArrayList对外提供了两个add方法，add(E e)和add(int index, E element)，前者是直接在ArrayList尾部追加元素，后者是在指定的位置添加元素。

public boolean add(E e) {
	//记录结构上被修改的次数
	modCount++;
	add(e, elementData, size);
	return true;
}

private void add(E e, Object[] elementData, int s) {
	//如果当前数组长度等于ArrayList容量则扩容
	if (s == elementData.length)
		elementData = grow();
	elementData[s] = e;
	size = s + 1;
}

public void add(int index, E element) {
	//检查下标是否越界
	rangeCheckForAdd(index);
	modCount++;
	final int s;
	Object[] elementData;
	//如果当前数组长度等于ArrayList容量则扩容
	if ((s = size) == (elementData = this.elementData).length)
		elementData = grow();
	//把index位置及其后的元素向后移动一位
	System.arraycopy(elementData, index,
					 elementData, index + 1,
					 s - index);
	elementData[index] = element;
	size = s + 1;
}

get

get方法比较简单，首先检查下标是否越界，然后找到数组中指定下标的元素。

public E get(int index) {
	Objects.checkIndex(index, size);
	return elementData(index);
}

remove

ArrayList也对外提供了两个remove方法public E remove(int index)和public boolean remove(Object o)，前者根据指定下标删除元素，后者传入一个对象，将ArrayList中的这个对象删除，都是通过调用fastRemove方法进行实际删除元素的。

public E remove(int index) {
	Objects.checkIndex(index, size);
	final Object[] es = elementData;

	@SuppressWarnings("unchecked") E oldValue = (E) es[index];
	fastRemove(es, index);

	return oldValue;
}

public boolean remove(Object o) {
	final Object[] es = elementData;
	final int size = this.size;
	int i = 0;
	//遍历数组是否有该对象并找到对应下标
	found: {
		if (o == null) {
			for (; i < size; i++)
				if (es[i] == null)
					break found;
		} else {
			for (; i < size; i++)
				if (o.equals(es[i]))
					break found;
		}
		return false;
	}
	fastRemove(es, i);
	return true;
}

fastRemove方法：

private void fastRemove(Object[] es, int i) {
	modCount++;
	final int newSize;
	if ((newSize = size - 1) > i)
		//把i+1之后的元素往前移动一位
		System.arraycopy(es, i + 1, es, i, newSize - i);
	//size-1位置置为空，对象最后会被gc
	es[size = newSize] = null;
}

扩容

ArrayList扩容是通过调用grow方法，在add方法和ensureCapacity都有出现。

ensureCapacity方法，传入一个最小容量，如果最小容量大于实际容量则扩容到最小容量。

public void ensureCapacity(int minCapacity) {
	if (minCapacity > elementData.length
		&& !(elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
			 && minCapacity <= DEFAULT_CAPACITY)) {
		modCount++;
		grow(minCapacity);
	}
}

下面看下grow方法：

private Object[] grow(int minCapacity) {
	int oldCapacity = elementData.length;
	if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
		//获取新容量大小
		//oldCapacity右移一位即是原长度的一半，ArraysSupport.newLength方法选择minCapacity - oldCapacity或oldCapacity >> 1较大的一方与oldCapacity相加。
		int newCapacity = ArraysSupport.newLength(oldCapacity,
												  minCapacity - oldCapacity, /* minimum growth */
												  oldCapacity >> 1           /* preferred growth */);
		//将之前元素迁移到新数组，返回按照新容量扩容后的数组
		return elementData = Arrays.copyOf(elementData, newCapacity);
	} else {
		//如果容量为0，则按照默认容量创建一个数组。
		return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
	}
}

private Object[] grow() {
	return grow(size + 1);
}

参考资料

1. ArrayList 源码分析
2. 【Java容器（jdk17）】ArrayList深入源码，就是这么简单