ArrayList源码详解

必要的初始知识

System.arraycopy这个东西最好要知道一下,这是ArrayList各种操作的核心.

构造器部分

给定一个初始值,然后用这个初始值声明数组.

**
     * Constructs an empty list with the specified initial capacity.
     *
     * @param  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative(负数)
     */
      // 用初始长度去声明一个空的列表(list),initialCapacity固初始化长度,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);
        }
    }

不给定初始值,用默认的空数组赋值

 /**
     * Constructs an empty list with an initial capacity of ten.
     */
//如果不进行赋值就用一个之前声明过的数组赋值
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

给定的初始值是一个集合

/**
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *创建一个列表(list)包含一个已经指定元素的集合,用由那个集合的迭代器按顺序返回
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection c) {
        elementData = c.toArray();//将输入的集合化为数组--Object[]数组.
        //如果输入的集合不为空
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            //对于这段话的解释https://www.cnblogs.com/gilbertbright/p/11714334.html
            if (elementData.getClass() != Object[].class)
                //如果输入的内容不是object类型,则要按照那个类型去进行赋值.
                //original - 要复制的数组 
               //newLength - 要返回的副本的长度 
               //newType - 要返回的副本的类 
                //将elementData到Object数组中,即让他们的类型产生变化
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

c.toArray might (incorrectly) not return Object[] (see 6260652)是什么意思

https://www.cnblogs.com/liqing-weikeyuan/p/7922306.html 这个也是个很好的问题

本类的成员变量

   private static final long serialVersionUID = 8683452581122892189L;

    /**
     * Default initial capacity.初始化长度.  
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * Shared empty array instance used for empty instances.
     */
    private static final Object[] EMPTY_ELEMENTDATA = {};//如果故意在有参构造函数中传0用的数组.

    /**
     * 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 = {};//如果用空参构造函数,把这个作为空参构造函数的值.

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access//ArrayList的底层函数

    /**
     * The size of the ArrayList (the number of elements it contains).
     *ArrayList的长度
     * @serial
     */
    private int size;

java集合-ArrayList中EMPTY_ELEMENTDATA与DEFAULTCAPACITY_EMPTY_ELEMENTDATA的区别

缩减函数

/**
 * Trims the capacity of this ArrayList instance to be the
 * list's current size.  An application can use this operation to minimize
 * the storage of an ArrayList instance.
 */
//缩减这个ArrayList实例的容量道它的最优大小.一个程序可以用这个操作去缩小一个ArrayList实例的大小.
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        //如果size为0就给他变回空数组,如果不是空数组,则复制它的数组,截掉那部分值为0的尾部
        1,2,3,4,0,0,0->1,2,3,4
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}

计算最小扩容长度函数(预备)

/**
 * Increases the capacity of this ArrayList instance, if
 * necessary, to ensure that it can hold at least the number of elements
 * specified by the minimum capacity argument.
 *
 * @param   minCapacity   the desired minimum capacity//最小需求容量
 */
//增加这个ArrayList的容量,如果是不必要的,保证这个ArrayList中的元素数量是最小容量.
//在扩容的时候使用的函数,保证扩容增长的长度是最小的长度.
public void ensureCapacity(int minCapacity) {
    //最小扩展量
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        //如果不是固定的那个空数组,最小的扩展就是0
        ? 0
        // larger than default for default empty table. It's already
        // supposed to be at default size.
        //如果传入的数比默认的空数组大,也被建议先采用默认值.
        : DEFAULT_CAPACITY;
//如果最小需求容量大于最小扩展值(最小扩展值实际上只在空ArrayList被第一次加入元素的时候才有用处[用处是直接把容量从0加到10],其他时候没用)
    if (minCapacity > minExpand) {
        //确定准确的ArrayList容量是什么.
        ensureExplicitCapacity(minCapacity);
    }
}

如上函数被addAll()用到的



如下函数是被add()用到的


//确定这个最小容量的大小.
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    //如果elementData还是最小初始数组   
    <---2.被 ensureCapacityInternal调用,返回值给ensureExplicitCapacity
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
       //看看这个最小容量大还是规定的默认长度(10)大,返回大的那个
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}
//如果
private void ensureCapacityInternal(int minCapacity) {  <---1.被add()方法调用
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
//确定准确的ArrayList容量是什么.
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

扩容函数

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
//增加容量去确保ArrayList拥有至少由最小容量给定的容量.
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;//老板长度
    int newCapacity = oldCapacity + (oldCapacity >> 1);//old+old/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);
}

增加函数

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

上面三个函数要一同看

当调用一个add()方法的时候首先运行的是 ensureCapacityInternal(size + 1);方法,判断ArrayList是否需要扩容.在这个函数中会先调用private static int calculateCapacity(Object[] elementData, int minCapacity) 函数,去对增加的数量进行判断.

对于用空参构造函数构造的ArrayList,为了节省空间实际上使用的是一个空数组,并没长度(并不是10).所以在这个函数中要判断增加的元素数量是否大于10(也就是ArrayList的默认长度),如果不大于10,用10作为容量,反之用传入的那个长度作为容量.

然后调用private void ensureExplicitCapacity(int minCapacity)在这里又进行了另一次判断,这里要注意传入的容量(minCapacity)未必大于ArrayList的现有长度.,所以在这里要有一次判断判断是否应该要调用grow()方法进行扩大.

一个toArray()方法

public  T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            //用传入的值去更改这个ArrayList中的所有内容
            //Arrays.copyOf复制指定的数组，用空值截断或填充（如有必要），以便复制具有指定的长度。
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;//如果进来的数组长度大于ArrayList长度,则将数组中最后一个设置为空.
        return a;//返回数组
    }

一个get()方法

public E get(int index) {
    rangeCheck(index);

    return elementData(index);
}
  E elementData(int index) {
        return (E) elementData[index];
    }//返回index位置上的索引的值

get()方法是由两个函数组成.目标是更加的简洁

set()方法也是大体如此

public E set(int index, E element) {
    rangeCheck(index);//确定没有超出边界

    E oldValue = elementData(index);//保留原先的值
    elementData[index] = element;//覆盖新的值
    return oldValue;//将原先的值返回
}

增加函数

public void add(int index, E element) {
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!//判断是否需要扩容,上面讲过了.
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);//从index位置上的元素开始将后面的所有元素(总长度size-索引位置index)挪到index+1的位置上
    elementData[index] = element;//把值放在index索引处
    size++;//长度计数器增加.
}

减小函数

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);//取出原先的值

    int numMoved = size - index - 1;//因为index上的值消失,所以实际上是从index+1开始的,也正是因此要多减一个
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);//从index+1开始复制,一直到数组解为,粘贴到index开始的位置上
    //此时会有两个最后一个元素,让他为空
    elementData[--size] = null; // clear to let GC do its work
    //如果一个对象所有的引用都为空,则与GC-root断链,会被JVM标记,然后清除.
    return oldValue;
}

add All()

public boolean addAll(Collection c) {
    Object[] a = c.toArray();//将传入的集合化为数组,每个集合中的元素都会被擦除成Object类型.
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);//从a(传入数组)的0位置复制该数组长度,从size开始粘贴到ArrayList维护的底层数组.
    size += numNew;
    return numNew != 0;
}

这个本质来讲没啥区别,但是重点是用到了ensureCapacityInternal(size + numNew); 这个方法,在上面的模块中,这个一直没用用到.请回到上面去看一下.注意minCapacity为最小需求容量.上面可能有些出入,请记住这个意思.

如上就是我们经常用到的ArrayList方法的详解.

还有一部分方法,大多原理和如上几个方法重复,或者平时基本不用.就不再写出来了.