ArrayList 源码分析：自增原理

目录

前言

ArrayList简介

预备知识

容量增长机制

Add（）方法

增长策略：Grow（）

容量扩充代码分析

构造器分析

---

前言

ArrayList是平时比较常用的集合类，因为其容量自动增长的特性，使我们可以非常方便的使用，且不用担心容量的问题，但是其内部是如何工作的，网上有许多的分析文章，但都过于枯燥，特别是对于溢出处理的部分。所以本文采用了直观的图像分析数组容量的不同大小时，会如何执行扩充策略；文章末尾也对ArrayList的构造器进行了分析

---

ArrayList简介

简单来说，ArrayList是一个动态增长的数组，内部封装了一个Object[]数组来实际的进行存储，所以该类的核心就在于其是如何实现容量自动扩充，并且保证不会发生溢出的

 

预备知识

• Java基本类型int，采用4个字节存储，共32位，首位为符号为（0正1负），故int型能表示的正值范围为0x00000000～0x7fffffff，如果两个int值进行加法运算后，值大于0x7fffffff，则会因为进位导致符号为从0变为1，导致变为负数（溢出问题）
• 部分虚拟机会在数组中存放头信息，所以实际的存储容量无法达到0x7fffffff，ArrayList中规定数组最大的容量为0x7fffffff-8

---

容量增长机制

Add（）方法

ArrayList之所以能够实现容量自动增长，关键就在于第一行代码，每次执行add（）操作，都能计算数组的容量是否能够满足要求，并实现自动增长。容量的增长机制核心在于grow方法（见下文），这里是对整个调用链进行一个简单的分析，不必深究

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

 ensureCapacityInternal

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

ensureExplicitCapacity：确认明确的容量大小
只有当elementData[]已满时，才会实际进行容量扩充（通过调用grow（）方法）

modCount是用来记录修改次数的，防止并发操作中，造成的数据不一致问题

// overflow-conscious code 
 因为int类型为4个字节，最大值为0x7fffffff，如果最大值+1，则会变成0x80000000 产生溢出。
0x80000000实际为-0，但是0x0000000也表示0，所以为了增强利用率，规定0x8000000 = -2^31 

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

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

calculateCapacity

计算实际的minCapacity，实际上就是用于区分用户在构造动态数组时，选择的是自定义初始容量还是默认容量

• 若用户在调用构造器时，指定了初始容量，则此方法直接返回传入参数的值，不做处理
• 如果用户调用的是默认构造器，那么选择DEFAULT_CAPACITY和minCapacity（size+1）中的最大值，作为返回值

若为第一次添加元素，那么size+1=1，minCapacity将会被设为10

【为什么默认容量为10？】如果太大则会浪费内存，如果太小则导致频繁扩充容量，所以选择一个适中的默认值

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

 

增长策略：Grow（）

ArrayList中数组的长度用int型来表示，最大长度为0x7fffffff，但是因为二进制的运算会造成溢出，所以在grow方法中并不是简单的按照1.5倍的速度进行容量扩充，我们通过图片可以直观的看到当数组容量大小不同时的容量扩充策略

我们将数组的原size容量大小分为4个区域，分别是

（以下四个区域的容量计算，直接对应grow方法中的if执行，只需要按照当前数组带回源码中即可理解）

I：绝对安全区（此区域内执行1.5倍增长策略，不会发生溢出）

II：若size处于此区域，则newCapacity不会溢出，但会处于Iv区域，执行hugeCapacity方法，新的数组容量为MAX_ARRAY_SIZE

III：若size处于此区域，则按照1.5倍扩充容量会使newCapacity发生溢出，将newCapacity赋值为minCapacity（size+1）

Iv：若size=0x7fffffff-8，则newCapacity=minCapacity（size+1）>MAX_ARRAY_SIZE,执行hugeCapacity方法，新的数组容量为MAX_VALUE

执行到这里，数组的容量已经达到最大，如果说继续向数组中添加元素，当元素数量达到0x7fffffff时，会再次触发grow方法，minCapacity=size+1=0x7fffffff+1=0x80000000=-2^31 抛出OOM异常

容量扩充代码分析

• int newCapacity = oldCapacity + (oldCapacity >> 1);

  默认扩充至原容量的1.5倍      oldCapacity>>1：二进制操作，右移一位，等同于oldCapacity/2

• if (newCapacity - minCapacity < 0)(为什么不直接判断newCapacity<0)？

  扩充时，由于int类型的存储限制，可能会产生溢出，所以需要进行溢出判断，若超过容量限制，则将newCapacity=minCapacity（size+1） （说明当arraylist中存储的对象数量达到一定数量（MAX_VALUE/1.5）后，每次进行add（）操作都要进行一次容量扩充，且只扩充一个元素的空间，效率是比较低下的）  

• if (newCapacity - MAX_ARRAY_SIZE > 0)

 

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

 

 

容量扩充方法：这部分涉及到类相关知识

elementData = Arrays.copyOf(elementData, newCapacity);

调用Arrays类封装的复制方法，调用链如下,最终是调用本地方法System.arraycopy方法进行的复制

• elementData = Arrays.copyOf(elementData, newCapacity);

• public static <T> T[] copyOf(T[] original, int newLength) {
      return (T[]) copyOf(original, newLength, original.getClass());
  }

• public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
      @SuppressWarnings("unchecked")
      T[] copy = ((Object)newType == (Object)Object[].class)
          ? (T[]) new Object[newLength]
          : (T[]) Array.newInstance(newType.getComponentType(), newLength);
      System.arraycopy(original, 0, copy, 0,
                       Math.min(original.length, newLength));
      return copy;
  }

构造器分析

1.默认的无参构造器，将DEFAULTCAPACITY_EMOPTY_ELEMENTDATA引用赋值给this.elementData，在第一次执行add（）方法时，会将此数组容量扩充至DEFAULT_CAPACITY=10（具体的扩充方式见下文）

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

2.用户指定容量的构造器，初始容量若为0则将EMPTY_ELEMENTDATA赋值给elementData

 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);
        }
    }

3.参数为实现了Collection接口的集合

public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

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

    //两个空的Object类型数组

    //当用户显式声明数组长度为0时，将EMPTY_ELEMENTDATA赋给elementData
    private static final Object[] EMPTY_ELEMENTDATA = {};

    //当用户调用默认构造器时，将此变量赋给elementData
    //如果elementdata的引用时此变量，则当插入第一个元素时，会将容量扩展至DEFAULT_CAPACITY=10
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

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

    //数组中实际存放的元素个数
    private int size;

 

容量扩充方法：这部分涉及到类相关知识

elementData = Arrays.copyOf(elementData, newCapacity);

调用Arrays类封装的复制方法，调用链如下,最终是调用本地方法System.arraycopy方法进行的复制

• elementData = Arrays.copyOf(elementData, newCapacity);

• public static <T> T[] copyOf(T[] original, int newLength) {
      return (T[]) copyOf(original, newLength, original.getClass());
  }

• public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
      @SuppressWarnings("unchecked")
      T[] copy = ((Object)newType == (Object)Object[].class)
          ? (T[]) new Object[newLength]
          : (T[]) Array.newInstance(newType.getComponentType(), newLength);
      System.arraycopy(original, 0, copy, 0,
                       Math.min(original.length, newLength));
      return copy;
  }