/**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    transient Object[] elementData; // non-private to simplify nested class access

1     /**
2      * Default initial capacity.
3      */
4     private static final int DEFAULT_CAPACITY = 10;

 1     ensureCapacityInternal(size + 1);  // Increments modCount!!    添加元素时调用扩容
 2 
 3     private void ensureCapacityInternal(int minCapacity) 
 4         ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 5     
 6 
 7     private static int calculateCapacity(Object[] elementData, int minCapacity)  // 得到最小的扩容量
 8         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) 
 9             return Math.max(DEFAULT_CAPACITY, minCapacity); // 获取默认的容量和传入参数较大的一个值
10         
11         return minCapacity;
12     
13 
14     private void ensureExplicitCapacity(int minCapacity) 
15         modCount++;
16 
17         // overflow-conscious code
18         if (minCapacity - elementData.length > 0)
19             grow(minCapacity); // 扩容开始
20     
21 
22     /**
23      * Increases the capacity to ensure that it can hold at least the
24      * number of elements specified by the minimum capacity argument.
25      *
26      * @param minCapacity the desired minimum capacity
27      */
28     private void grow(int minCapacity) 
29         // overflow-conscious code
30         int oldCapacity = elementData.length;
31         int newCapacity = oldCapacity + (oldCapacity >> 1); //右移操作，相当于oldCapacity/2  扩容之后为原来的1.5倍，也称之为扩容系数
32         if (newCapacity - minCapacity < 0) // 新容量时否小于最小需要的容量，小于则新容量为最小需要容量
33             newCapacity = minCapacity;
34         if (newCapacity - MAX_ARRAY_SIZE > 0) //新容量比最大数组容量还大，则需要判断
35             newCapacity = hugeCapacity(minCapacity);
36         // minCapacity is usually close to size, so this is a win:
37         elementData = Arrays.copyOf(elementData, newCapacity);
38     
39 
40     private static int hugeCapacity(int minCapacity) 
41         if (minCapacity < 0) // overflow
42             throw new OutOfMemoryError();
43         return (minCapacity > MAX_ARRAY_SIZE) ?
44             Integer.MAX_VALUE :
45             MAX_ARRAY_SIZE;
46     

 1     /**
 2      * Appends the specified element to the end of this list.
 3      *
 4      * @param e element to be appended to this list
 5      * @return <tt>true</tt> (as specified by @link Collection#add)
 6      */
 7     public boolean add(E e) 
 8         ensureCapacityInternal(size + 1);  // Increments modCount!!
 9         elementData[size++] = e;
10         return true;
11     

 1     /**
 2      * Inserts the specified element at the specified position in this
 3      * list. Shifts the element currently at that position (if any) and
 4      * any subsequent elements to the right (adds one to their indices).
 5      *
 6      * @param index index at which the specified element is to be inserted
 7      * @param element element to be inserted
 8      * @throws IndexOutOfBoundsException @inheritDoc
 9      */
10     public void add(int index, E element) 
11         rangeCheckForAdd(index);
12 
13         ensureCapacityInternal(size + 1);  // Increments modCount!!
14         System.arraycopy(elementData, index, elementData, index + 1,
15                          size - index);
16         elementData[index] = element;
17         size++;
18     

 1     /**
 2      * Removes the element at the specified position in this list.
 3      * Shifts any subsequent elements to the left (subtracts one from their
 4      * indices).
 5      *
 6      * @param index the index of the element to be removed
 7      * @return the element that was removed from the list
 8      * @throws IndexOutOfBoundsException @inheritDoc
 9      */
10     public E remove(int index) 
11         rangeCheck(index);
12 
13         modCount++;
14         E oldValue = elementData(index);
15 
16         int numMoved = size - index - 1;
17         if (numMoved > 0)
18             System.arraycopy(elementData, index+1, elementData, index,
19                              numMoved);
20         elementData[--size] = null; // clear to let GC do its work
21 
22         return oldValue;
23     

elementData[--size] = null;

 1     /**
 2      * Removes the first occurrence of the specified element from this list,
 3      * if it is present.  If the list does not contain the element, it is
 4      * unchanged.  More formally, removes the element with the lowest index
 5      * <tt>i</tt> such that
 6      * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
 7      * (if such an element exists).  Returns <tt>true</tt> if this list
 8      * contained the specified element (or equivalently, if this list
 9      * changed as a result of the call).
10      *
11      * @param o element to be removed from this list, if present
12      * @return <tt>true</tt> if this list contained the specified element
13      */
14     public boolean remove(Object o) 
15         if (o == null) 
16             for (int index = 0; index < size; index++)
17                 if (elementData[index] == null) 
18                     fastRemove(index);
19                     return true;
20                 
21          else 
22             for (int index = 0; index < size; index++)
23                 if (o.equals(elementData[index])) 
24                     fastRemove(index);
25                     return true;
26                 
27         
28         return false;
29     

 1     /*
 2      * Private remove method that skips bounds checking and does not
 3      * return the value removed.
 4      */
 5     private void fastRemove(int index) 
 6         modCount++;
 7         int numMoved = size - index - 1;
 8         if (numMoved > 0)
 9             System.arraycopy(elementData, index+1, elementData, index,
10                              numMoved);
11         elementData[--size] = null; // clear to let GC do its work
12     

 1     /**
 2      * Returns @code true if the iteration has more elements.
 3      * (In other words, returns @code true if @link #next would
 4      * return an element rather than throwing an exception.)
 5      *
 6      * @return @code true if the iteration has more elements
 7      */
 8     boolean hasNext();
 9 
10     /**
11      * Returns the next element in the iteration.
12      *
13      * @return the next element in the iteration
14      * @throws NoSuchElementException if the iteration has no more elements
15      */
16     E next();
17 
18     /**
19      * Removes from the underlying collection the last element returned
20      * by this iterator (optional operation).  This method can be called
21      * only once per call to @link #next.  The behavior of an iterator
22      * is unspecified if the underlying collection is modified while the
23      * iteration is in progress in any way other than by calling this
24      * method.
25      *
26      * @implSpec
27      * The default implementation throws an instance of
28      * @link UnsupportedOperationException and performs no other action.
29      *
30      * @throws UnsupportedOperationException if the @code remove
31      *         operation is not supported by this iterator
32      *
33      * @throws IllegalStateException if the @code next method has not
34      *         yet been called, or the @code remove method has already
35      *         been called after the last call to the @code next
36      *         method
37      */
38     default void remove() 
39         throw new UnsupportedOperationException("remove");
40     

 1  /**
 2      * An optimized version of AbstractList.Itr
 3      */
 4     private class Itr implements Iterator<E> 
 5         int cursor;       // index of next element to return
 6         int lastRet = -1; // index of last element returned; -1 if no such
 7         int expectedModCount = modCount;
 8 
 9         Itr() 
10 
11         public boolean hasNext() 
12             return cursor != size;
13         
14 
15         @SuppressWarnings("unchecked")
16         public E next() 
17             checkForComodification();
18             int i = cursor;
19             if (i >= size)
20                 throw new NoSuchElementException();
21             Object[] elementData = ArrayList.this.elementData;
22             if (i >= elementData.length)
23                 throw new ConcurrentModificationException();
24             cursor = i + 1;
25             return (E) elementData[lastRet = i];
26         
27 
28         public void remove() 
29             if (lastRet < 0)
30                 throw new IllegalStateException();
31             checkForComodification();
32 
33             try 
34                 ArrayList.this.remove(lastRet);
35                 cursor = lastRet;
36                 lastRet = -1;
37                 expectedModCount = modCount;
38              catch (IndexOutOfBoundsException ex) 
39                 throw new ConcurrentModificationException();
40             
41         
42 

 1     /**
 2      * Replaces the element at the specified position in this list with
 3      * the specified element.
 4      *
 5      * @param index index of the element to replace
 6      * @param element element to be stored at the specified position
 7      * @return the element previously at the specified position
 8      * @throws IndexOutOfBoundsException @inheritDoc
 9      */
10     public E set(int index, E element) 
11         rangeCheck(index);
12 
13         E oldValue = elementData(index);
14         elementData[index] = element;
15         return oldValue;
16     

 1     /**
 2      * Returns the element at the specified position in this list.
 3      *
 4      * @param  index index of the element to return
 5      * @return the element at the specified position in this list
 6      * @throws IndexOutOfBoundsException @inheritDoc
 7      */
 8     public E get(int index) 
 9         rangeCheck(index);
10 
11         return elementData(index);
12