默认构造函数：
/** * Constructs an empty list with an initial capacity of ten. */ public ArrayList() { this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; }从上面的DEFAULTCAPACITY_EMPTY_ELEMENTDATA 这个参数的的名字可以看出是默认的空的元素数据。但DEFAULTCAPACITY_EMPTY_ELEMENTDATA的数据类型是什么呢？
我们接着再看，
/** * Shared empty array instance used for default sized empty instances. We * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when * first element is added. */ private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};就是一个空的一维数组，不过注释中提到了default sized empty instance，那么default size 到底是多少呢？还是不知道，那么我们可以转换下看思路看能不能从类的属性中找到呢？简单点，望文生义，
/** * Default initial capacity. */ private static final int DEFAULT_CAPACITY = 10;默认是10；
那么，这算不算是把ArrayList的构造函数阅读完了呢？不算，因为还没有将DEFAULT_CAPACITY 和上面的DEFAULTCAPACITY_EMPTY_ELEMENTDATA一维空数组关联起来，接下来通过阅读另一个构造函数ArrayList(int initialCapacity),看看有什么收获？
/** * Constructs an empty list with the specified initial capacity. * * @param initialCapacity the initial capacity of the list * @throws IllegalArgumentException if the specified initial capacity * is negative */ 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); } }这段代码很好理解：如果是initialCapacity的数值大于0，就使用initalCapacity开辟数组，如果等于0，就使用默认容量，如果为负数，就抛异常。
容量，数组中元素的个数，是什么关系？
关键问题： 1. 当数组满了时候，ArrayList是如何处理的？即扩容问题 2. 扩容的过程中使用的怎样的策略，来保证原来数组中的数据不丢失？
先解决第一个问题：
/** * Appends the specified element to the end of this list. * * @param e element to be appended to this list * @return <tt>true</tt> (as specified by {@link Collection#add}) */ public boolean add(E e) { ensureCapacityInternal(size + 1); // Increments modCount!! elementData[size++] = e; return true; }不好理解的是ensureCapacityInternal这个方法，但从字面上理解，就是确保容量足够，那么是怎样确保容量足够呢？如果所有的内存都占用完了呢？怎么办？这个问题也是我被腾讯面试官问到的问题，如果这个方法执行完毕，就可以正常的添加元素了，接下来就看看ensureCapacityInternal这个函数
private void ensureCapacityInternal(int minCapacity) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity); } ensureExplicitCapacity(minCapacity); }最小容量等于默认容量和最小容量的最大值，那么接下来 ensureExplicitCapacity函数应该就是扩内存容量的，源码中就有grow方法。
private void ensureExplicitCapacity(int minCapacity) { modCount++; // overflow-conscious code if (minCapacity - elementData.length > 0) grow(minCapacity); }问题1、modCount作用？2、grow方法内部实现是怎样的？ 解决问题1，看源码读注释:
/** * 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. * * <p>This field is used by the iterator and list iterator implementation * returned by the {@code iterator} and {@code listIterator} methods. * If the value of this field changes unexpectedly, the iterator (or list * iterator) will throw a {@code ConcurrentModificationException} in * response to the {@code next}, {@code remove}, {@code previous}, * {@code set} or {@code add} operations. This provides * <i>fail-fast</i> behavior, rather than non-deterministic behavior in * the face of concurrent modification during iteration. * * <p><b>Use of this field by subclasses is optional.</b> If a subclass * wishes to provide fail-fast iterators (and list iterators), then it * merely has to increment this field in its {@code add(int, E)} and * {@code remove(int)} methods (and any other methods that it overrides * that result in structural modifications to the list). A single call to * {@code add(int, E)} or {@code remove(int)} must add no more than * one to this field, or the iterators (and list iterators) will throw * bogus {@code ConcurrentModificationExceptions}. If an implementation * does not wish to provide fail-fast iterators, this field may be * ignored. */ protected transient int modCount = 0;关键句The number of times this list has been structurally modified.就是说明了modCount的作用是表示修改的次数。至于这个属性的详细作用可以从接下来的注释中去看。
解决问题2：
/** * Increases the capacity to ensure that it can hold at least the * number of elements specified by the minimum capacity argument. * * @param minCapacity the desired minimum capacity */ 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); }划重点：旧容量等于数组的长度，新容量为旧容量的1.5倍，因为oldCapacity>>1是0.5倍的oldCapacity，再加上原来的oldCapacity，即为1.5倍。如果新容量小于最小容量，那么新容量等于最小容量（就是取两者中的最大值）。接着看，如果新容量大于MAX_ARRAY_SIZE（最大数组容量），那么新的容量就等于hugeCapacity(minCapacity)的容量。关键问题：hugeCapacity方法的作用是？如果以上语句都执行了，就将原来的数组复制到新的容量的数组中。没说的。
解决hugeCapacity方法的作用是？
private static int hugeCapacity(int minCapacity) { if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE; }问题：minCapacity有没有可能小于0，报OutOfMemoryError，个人感觉不可能，因为这个minCapacity还是从add方法中来的。等于size+1;下面就是minCapacity大于MAX_ARRAY_SIZE(最大数组容量)，就返回整型数据的最大值，否则就返回MAX_ARRAY_SIZE。就是说普通情况下ArrayList的最大的容量就是Integer.MAX_VALUE。这个ArrayList的峰值。
本文主要梳理了ArrayList的扩容策略，简单点，就是当容量不足时，开辟一个新数组，将就数组中的元素都赋值过去。再这个过程中的，难点是开辟新数组的容量如何设置的问题。
