ArrayList扩容机制

java 版本：1.8
类查看的流程：
add()
ensureCapacityInternal()
ensureExplicitCapacity()
grow()

ArrayList源码：
这里只贴出最重要的需要分析的代码

// 默认的一个容量大小
private static final int DEFAULT_CAPACITY = 10;
// 以下三个留个印象 主要用于列表的初始化使用
private static final Object[] EMPTY_ELEMENTDATA = {}; 
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
transient Object[] elementData; 
// 可以理解为一个计数器，每添加一个元素+1 需要记住
 private int size;
/*
构造函数有三个  用的最多的是前两个，这里就介绍前两个
*/
//有参构造 初始化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);
        }
    }
//无参构造
 public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

因为是扩容机制的分析，元素的添加才会导致扩容机制的触发，所以元素的添加是突破口

下面几个函数依次分析

  public boolean add(E e) {
  		// 这个就是扩容机制的一个检测点
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    //获取最小的容量 这里的minCapacity 就是我们上面说的计算器，牢记成计算器
 private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    //计算最小的容量，
 private static int calculateCapacity(Object[] elementData, int minCapacity) {
 		// 这里主要是判断无果是无参构造 ，那么初始化容量就直接扩容为10，有参的话就返回当前计数器数值
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //不是的话 就返回最小容量也就是我们的计数器，
        return minCapacity;
    }
    // 判断是否需要扩容 
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // 如果是无参，那么就判断当前元素的长度和最最小容量，成立后进入Grow函数进行扩容，扩容后elementData.length=10，直到最小容量也就是计数器的数值大于10的时候在进行第二次扩容
        //如果是有参构造的话，直接比较计数器和当前列表的长度，成立的时候在进行第一次扩容
        if (minCapacity - elementData.length > 0)
        // 扩容核心函数
            grow(minCapacity);
    }
  private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //使用了位运算  最后结果取整
        //ex:10>>3  ->1  10/8=1
        //ex:8>>3  ->    8/8=1
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        // 再次比较计算器的值和新容量的大小
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // 扩容最后也就是列表的一个复制，返回一个新的数组
        elementData = Arrays.copyOf(elementData, newCapacity);
      
    }

差不多以上就是ArrayList的扩容机制全部内容，若有不足之处还请不吝赐教，

扩容列表的复制使用的底层也是 使用的System.arraycopy();

System.arraycopy详细使用