关于ArrayList源码跟踪

ArrayList内部实现

ArrayList定义

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

//AbstractList内部定义
protected transient int modCount = 0;

ArrayList内部是通过数组实现的

//ArrayList内部定义一下变量

//定义一个Object类型的数组
transient Object[] elementData;

//定义一个空的Object类型的数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

//定义一个int类型的size变量
private int size;

//定义数据默认扩容大小为10
private static final int DEFAULT_CAPACITY = 10;

//定义一个int类型的最大值
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

无参构造函数

ArrayList arrayList = new ArrayList();

//无参构造函数内部初始化了elementData数组
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;//将Object空数组赋值给elementData
}

通过add添加元素

arrayList.add("a");

public boolean add(E e) {
    //确保内部容量大小
    ensureCapacityInternal(size + 1);  // Increments modCount!!    size默认是0
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //如果为true则代表是第一次
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //取DEFAULT_CAPACITY和minCapacity，其中较大的值，DEFAULT_CAPACITY为10.所以这就是为啥ArrayList默认初始大小为10
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;//记录调整次数
    
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

//数组真正扩容方法
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;//数组原来长度
    int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容后的长度 =原来长度+原来长度/2
    if (newCapacity - minCapacity < 0)
        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);//数组的扩容
}

 private static int hugeCapacity(int minCapacity) {
     if (minCapacity < 0) // overflow
         throw new OutOfMemoryError();
     //三元运算符  返回两个值中较小的一个
     return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE :  MAX_ARRAY_SIZE;
 }

代码debug

扩展

transient 是Java语言的关键字，用来表示一个成员变量不是该对象序列化的一部分。当一个对象被序列化的时候，transient型变量的值不包括在序列化的结果中。

数组扩容长度

//声明int类型数据，并初始化三个元素
int[] arr = {1, 2, 3};
//通过Arrays.copyOf方法将arr数据长度扩容到10个元素
arr = Arrays.copyOf(arr, 10);

Idea配置设置

debug可以查询所有的信息