Java集合框架—ArrayList—扩容原理底层源码

Java.util.ArrayList是Java集合中更常见的类，也是Java开发中更常见的类之一。本篇基于JDK9，从ArrayList的基本用法开始，以源码中add()方法的完整实现过程，来预测ArrayList扩容原理的推动。

1.普通ArrayList,可以装任意Object对象。

List list = new ArrayList();

2.泛型类ArrayList,装指定种类的对象，如String类:

List<String> list = new ArrayList<>();

初始化时可以设定函数容量：

List list = new ArrayList(10);List<String> list = new ArrayList<>(10);

也可以直接初始化赋值：

List<String> list = new ArrayList<>(){{add("A");add("B");add("C");}};

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));

1.添加元素add()

List<String> list = new ArrayList<>();

add有两种重载的方式，分别是直接添加元素跟给数组为index的位置添加元素。

list.add("A");         //此时list中有一个String对象：A
list.add(1,8);        //给下标为1的位置添加Integer对象:8

注意，要是给不存在的下标位置添加元素，如list.add(3,8);则会导致异常：IndexOutOfBoundsException表示下标越界;如果list.add(index,obj);index下标对应的位置已有对象，则此对象及以后的对象全部依次后移一位。

代码如下:

运行结果:

新建一个ArrayList:
[A, B, C]
[A, D, B, C]

2.删除元素remove()

remove和add类似，也有两种重载的方式，分别是直接删除和依据下标index删除

List list = new ArrayList(Arrays.asList("A","B","C","B","C"));

此时数组中元素为A,B,C,B,C，此时list.remove("C")会移除第一个匹配到的"C"

remove()后的数组:

A,B,B,C

再进行list.remove(1)，数组变为：

A,B,C

同样有一点需要留意：如果移除不存在的元素，并不会报错；但是移除不存在的下标，如

list.remove(99)则也会报IndexOutOfBoundsException异常。

代码如下：

运行结果：

初始ArrayList:[A, B, C, B, C]
[A, B, B, C]
[A, B, C]

3.查看元素get()

查看元素只有一种方法：get(index)，即借助下标来查看对应的元素，如果下标不存在也会报IndexOutOfBoundsException异常。

代码如下：

运行结果：

初始ArrayList:[A, B, C]
get(1)查看'1'号元素：B

4.修改/重置元素set

set()和get()一样，只有一种方式，即借助下标index来设置相应位置元素的值。

代码如下：

运行结果：

初始ArrayList:[A, D, C]
[A, B, C]

5.除了get,set,add和remove外，ArrayList还要很多常见方式：

size()返回元素个数，addAll()合并另一个集合类，toArray()将ArrayLIst转化为Object数组，

indexOf()返回某个元素第一次出现的位置下标index，subList()截取指定下标范围的子List。

代码如下:

运行结果:

la.toString():[A, B, C]
la.addAll(1,lb):[A, B, C, D, B, C]
la.toArray():[Ljava.lang.Object;@3f0ee7cb
ABCDBCla.indexOf("B"):1
la.lastIndexOf("B"):4
la.subList(0,3):[A, B, C]

首先，看一下ArrayList的源码定义：

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

ArrayList类继承自抽象类AbstractList，实现了List接口，随机存取RandomAccess接口，克隆接口Cloneable，序列化接口Serializable。

通常，我们使用Arraylist添加一个对象通常无需过多考虑，直接add()即可，无需担心其容量是否达到限制，其原因就在于Arraylist源码中，实现add()方法之前会查看其容量是否够用，不够则会手动‘扩容’然后再执行add()添加元素，即自动扩容。

让我们从一个空的字段列表添加元素开始，看一下源码是怎样实现的。

List list = new ArrayList();
list.add("A");

首先，List list = new ArrayList();初始化了一个空字符列表list，具体是ArrayList类源码中：

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

初始化ArrayList对象的同时建立了一个默认为空的Object数组变量elementData。然后list.add("A")对应的是源码中的add()方法：

如图中所示，public boolean add(E e){}方法会执行modCount++;然后调用add(e,elementData,size)方法，最后返回布尔类型的ture。

modCount在ArrayList中定义如下：

protected transient int modCount = 0;

doc说明：

/**

* The number of times this list has been <i>structurally modified</i>.

* Structural modifications are those that change the size of the

* list, or otherwise perturb it in such a fashion that iterations in

* progress may yield incorrect results....

很多结构化地改变变量的操作就会用到modCount计数，用来标志数组被更改的数量。譬如add , set , remove等。

由于是初次添加元素，故modCount++后变为1，来到下一步add(e, elementData, size)，此时e为应添加的元素：“A”，elementData为今天创建的Object[], size为函数初始容量，值为0(在ArrayList中定义：private int size，int型初始未赋值则为0)

重点看下add方法的详细实现：

private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
}

由于初始elementData.length==size==0故执行grow()方法list java 容量，返回值赋给elementData。

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

grow有两个重载的方式，无参的grow()会调用有参的grow，参数为size+1。

private Object[] grow(int minCapacity) {
        return elementData = Arrays.copyOf(elementData,
                                           newCapacity(minCapacity));
    }

此处size+1=1作为minCapacity，表示最小容量，实际也很高理解，因为add一个对象首先我需要的最小容量是原尺寸+1，有了最小容量能够进行下一步地添加元素操作，所以借助grow()来推动我arraylist对象的长度，即【扩容】

扩容的操作通过Arrays.copyOf方法实现：

Arrays.copyOf(elementData,newCapacity(minCapacity))

此方式直接将原变量elementData复制到一个新的给定长度的变量中，并返回此新数组对象。

那么新数组长度是多少呢？这个就是newCapacity()中定义的，让我们看一下：

private int newCapacity(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity <= 0) {
            if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                return Math.max(DEFAULT_CAPACITY, minCapacity);
            if (minCapacity < 0) // overflow
                throw new OutOfMemoryError();
            return minCapacity;
        }
        return (newCapacity - MAX_ARRAY_SIZE <= 0)
            ? newCapacity
            : hugeCapacity(minCapacity);
}

1.int oldCapacity = elementData.length

此处因为elementData是空数组，所以oldCapacity==elementData.length==0

2.newCapacity = oldCapacity + (oldCapacity >> 1)

这一步是扩容的核心操作list java 容量，即扩容后新变量的宽度=原函数的容量+原变量的容量/2.

通过oldCapacity >> 1(Java移位运算，右移1位相当于除以2)来推动扩容原数组容量的一半

，即ArrayList的扩容是按照原容量的1.5倍来扩容的。

但是此时oldCapacity值为0故newCapacity也为0，扩容无效...

3.if(newCapacity - minCapacity <=0)

经过第二步后的newCapacity=0，小于minCapacity=1故处于以下的步骤：

if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
    return Math.max(DEFAULT_CAPACITY, minCapacity);
if (minCapacity < 0) // overflow
    throw new OutOfMemoryError();
return minCapacity;

4.return Math.max(DEFAULT_CAPACITY, minCapacity);

DEFAULT_CAPACITY为ArrayList中初始的默认容量，大小为10。定义如下：

/**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;

return Math.max(DEFAULT_CAPACITY, minCapacity)返回10和minCapacity中的最大值，此处直接返回10

现在，经过newCapacity()计算后的新变量容量为10，让我们重回grow()中的：

return elementData = Arrays.copyOf(elementData,newCapacity(minCapacity))

Arrays.copyOf将elementData复制至一个容量为10的新Object[]中去，并返回此函数对象elementData，完成了后面一大堆准备工作，并执行扩容后，终于来到了add()方法中的最终两部：

elementData[s] = e;

完成新增元素添加

size = s + 1;

将该ArrayList对象的数量+1

源码部分步骤截图如下：

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-141795-1.html