ArrayList扩容原理

ArrayList的扩容机制

ArrayList是collection接口下的list接口的实现类，用来保存n个数据的集合，他的底层其实是一个object数组，依旧用的是数组方式保存数据。
哪么对于数组而言长度不可变，在我们添加时，如果数据已满就必须要再重新创建一个更大容量的数组，然后将原数据复制到新数组中再进行添加操作。
但是ArrayList并不需要我们手动的去创建，他在内部有一套完整的扩容方法。我们只需要去添加数据就可以内部会给我们重新开辟新数组。
所谓讲扩容机制也是解析源代码的一个过程，下边我根据代码执行顺序解释底层的实现逻辑。
直接看源码吧 下边只包含关于扩容的代码实现（按顺序执行），其中每行都有注释。

	// 无参构造方法
	public ArrayList() {
	//不传任何参数时，集合的内部实现是一个空数组（长度为0） 
	// Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
			this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
	}
	//有参构造方法
	public ArrayList(int initialCapacity) {
		if (initialCapacity > 0) {      //当确定创建的数组长度时，长度>0时；
			this.elementData = new Object[initialCapacity];//创建一个长度为initialCapacity的数组；
		} else if (initialCapacity == 0) {      //参数长度为0时， 
			this.elementData = EMPTY_ELEMENTDATA;   //将默认开辟一个长度为长度10的数组；
		} else {
			//参数不合规范时 抛出异常；
			throw new IllegalArgumentException("Illegal Capacity: "+
											   initialCapacity);
		}
	}

	// 基础扩容方法

	// 添加元素
	public boolean add(E e) {
		// 按照元素个数+1，确认数组容量是否够用
		ensureCapacityInternal(size + 1);
        //添加元素到集合内部的数组中；
		elementData[size++] = e;
        
		return true;
	}
                                //参数 ：所需最小长度
	private void ensureCapacityInternal(int minCapacity) {

		//calculateCapacity方法 返回一个暂定的新长度；
		//ensureExplicitCapacity方法内部判断是否进行扩容；
		ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
	}

                                //传入参数：原数组和所需最小长度
	private static int calculateCapacity(Object[] elementData, int minCapacity) {
		if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { //如果原数组等于空数组；

			            //判断所需要的长度和默认长度10谁大，则返回谁
						//用addAll方法时会判断（将一个集合添加到另一个集合中时）；
			return Math.max(DEFAULT_CAPACITY, minCapacity);  
		}
		//如果原数组不为空，直接返回所需最小长度；
		return minCapacity; 
	}
                                  //参数： 10 或 minCapacity;
	private void ensureExplicitCapacity(int minCapacity) {
		modCount++;

		
		//如果所需最小长度 < 原数组长度 则空间够用不扩容
		//如果相等 则证明添加元素刚好是数组最后一个元素也不需要扩容；
		if (minCapacity - elementData.length > 0)如果所需最小长度 > 原数组长度执行扩容方法 grow
			grow(minCapacity);
	}
	//参数：所需最小长度：10或minCapacity；
	private void grow(int minCapacity) {
		int oldCapacity = elementData.length;//数组原长度赋值给oldCapacity；
		int newCapacity = oldCapacity + (oldCapacity >> 1);//暂定 **数组新长度=原长度+(原长度/2)**

		if (newCapacity - minCapacity < 0)//如果扩容后数组新长度还小于所需最小长度，
			newCapacity = minCapacity;    //就将所需要最小长度赋值给数组新长度；

        //如果 此时新长度大于了2147483639（可能直接溢出，也可能在2147483639 ~ 2147483647）
		if (newCapacity - MAX_ARRAY_SIZE > 0)

            //hugeCapacity作用：溢出抛异常。不溢出则返回新长度2147483647或2147483639
			newCapacity = hugeCapacity(minCapacity);

		//将原数组赋值到新数组，新数组长度为newCapaticy
		elementData = Arrays.copyOf(elementData, newCapacity);
	}

	 private static int hugeCapacity(int minCapacity) {

		if (minCapacity < 0) // 所需最小长度不合规范（数据溢出），出现错误
			throw new OutOfMemoryError();

			//如果最小长度大于了2147483639，直接返回最大长度 2147483647否则返回2147483639
		return (minCapacity > MAX_ARRAY_SIZE) ?
			Integer.MAX_VALUE :
			MAX_ARRAY_SIZE;
	}

扩容方式的根本就在这句 （扩充后的长度时之前的1.5倍，也可以理解为增大了0.5倍。）
位运算右移相当于做除二的操作

int newCapacity = oldCapacity + (oldCapacity >> 1);//暂定 **数组新长度=原长度+(原长度/2)