学习笔记之集合：关于ArrayList底层实现的一些理解（1）

学的时候就很好奇，ArrayList究竟是如何实现动态数组的，看了很多大牛写的帖子分析，自我总结了一下，大概就是在判断数组要越界的时候，把原来的数据复制到新的容量更大的数组中去，不过，具体实现还是一头雾水，于是开始研究了底层的源码，写下来也是为了方便自己以后进一步学习和回顾。
先看一下类的结构

//默认初始的数组容量
 private static final int DEFAULT_CAPACITY = 10;
 //空数组
 private static final Object[] EMPTY_ELEMENTDATA = {};
 //默认初始化时的空数组
 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 //集合中存放数据的数组
 transient Object[] elementData;
 //用于表示集合长度，其实就是数组中的有效元素
 private int size;
 //这个字段继承自父类AbstractList，主要用于标识集合的版本情况，在执行一些操作集合的方法时，会自+1
 protected transient int modCount = 0;

以上是集合ArrayList中的一些成员属性

然后再来看看他的构造方法，
先看无参构造，这个在我的学习中用的是比较多的

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

这个就看起来很简单了，只初始化了数组为一个空的数组
PS:这个时候并没有指定集合的初始容量，也可以认为这个空数组其实就是初始容量，也就是0
实际上通过这个构造器构造出的数字，初始容量会在第一次执行add方法的时候，被初始化为10，也就是上面的
DEFAULT_CAPACITY的值，至于其他添加方法（addAll）的执行流程之后再说

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

1-1

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

1-2

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

1-3
执行到calculateCapacity这个方法是，会判断最小容量，但是如果这个时候elementData ={}的话，就会执行Math.max(DEFAULT_CAPACITY, minCapacity)这个方法，实际上刚执行玩无参构造，第一次添加数据时，minCapacity这个值是size+1，size初始值为0，所以这个函数返回值是10，初始容量其实就是在这里初始化。

	private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

然后执行到这步，然后会比较一下数组长度（集合的容量）以及增加数据后的最小长度（有效数据的个数）
这里数组长度为0，而最小容量为10，所以会执行grow方法

	private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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);
    }

这里是grow方法，看起来有点长，其实就是做了3件事，（1）把数组长度扩容成原来的1.5倍；（2）如果扩容后的数组容量还是比最小容量小的话，则扩容成最小容量，否则保持原来的1.5倍，顺便判断下数组长度是否超过数组允许的最大值，如果超过了，则有2钟方案

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

这里做了个判断，如果最小容量小于0的话，则抛出异常，否则，根据选择条件返回对应的数值
（3）将数据复制到新的扩容后的数组中去；
执行完扩容，之后，将要插入的数据让道size的位置上（数组下标从0开始），并把size自加1

之后每次插入新数据，都会把size+1和数组容量作比较，如果size+1超过了数组容量，则执行grow（）进行扩容
还有其他的方法下次再写了

新人刚开始学习，还请多多指教