1
            /*
              2
            继承自AbstractList，实现了List、RandomAccess、Cloneable、Serializable接口

              3
                1）RandomAccess接口：用来快速随机存取，在实现了该接口后，用普通for来遍历，性能更高

              4
                2）Cloneable接口：实现了该接口，就可以使用Object.Clone()方法了

              5
                3）Serializable接口：实现了该接口，表明该类可以被序列化

              6
            */
              7
            public
            class ArrayList<E> extends AbstractList<E>
  8implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  9{
 10//版本号 11privatestaticfinallong serialVersionUID = 8683452581122892189L;
 12//缺省容量 13privatestaticfinalint DEFAULT_CAPACITY = 10;
 14//缺省空对象数组 15privatestaticfinal Object[] EMPTY_ELEMENTDATA = {};
 16//默认大小的对象数组 17privatestaticfinal Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 18//元素数组 19transient Object[] elementData;
 20//数组的大小 21privateint size;
 22 23//构造方法
 24//无参构造 Constructs an empty list with an initial capacity of ten 25public ArrayList() {
 26this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
 27    }
 28 29/** 30     * Constructs an empty list with the specified initial capacity.
 31     *
 32     * @param  initialCapacity  the initial capacity of the list
 33     * @throws IllegalArgumentException if the specified initial capacity
 34     *         is negative
 35*/ 36public ArrayList(int initialCapacity) {
 37if (initialCapacity > 0) {
 38this.elementData = new Object[initialCapacity];
 39         } elseif (initialCapacity == 0) {
 40this.elementData = EMPTY_ELEMENTDATA;
 41         } else {
 42thrownew IllegalArgumentException("Illegal Capacity: "+
 43                                               initialCapacity);
 44        }
 45    }
 46 47/** 48     * Constructs a list containing the elements of the specified
 49     * collection, in the order they are returned by the collection‘s
 50     * iterator.
 51     *
 52     * @param c the collection whose elements are to be placed into this list
 53     * @throws NullPointerException if the specified collection is null
 54*/ 55public ArrayList(Collection<? extends E> c) {
 56         elementData = c.toArray();    //转换为数组 57if ((size = elementData.length) != 0) {    //数组长度大于0
 58// c.toArray might (incorrectly) not return Object[] (see 6260652) 59if (elementData.getClass() != Object[].class)    
 60                 elementData = Arrays.copyOf(elementData, size, Object[].class);
 61         } else {
 62// replace with empty array. 63this.elementData = EMPTY_ELEMENTDATA;
 64        }
 65    }
 66//总体而言：arrayList的构造方法就是做一件事，初始化一下储存数据的容器，
 67//            其实本质就是一个数组，在其中就叫elementData
 68 69//核心方法 70/** 71     * Appends the specified element to the end of this list.
 72     * 默认直接在末尾添加元素
 73     *
 74     * @param e element to be appended to this list
 75     * @return <tt>true</tt> (as specified by {@link Collection#add})
 76*/ 77publicboolean add(E e) {    //elementData=[1,2,3] e=6
 78//确保数组的容量足够 79         ensureCapacityInternal(size + 1);  // Increments modCount!!
 80//数组尾部添加元素e 81         elementData[size++] = e;
 82returntrue;
 83    }
 84 85privatevoid ensureCapacityInternal(int minCapacity) { //minCapacity=4 87        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
 88    }
 89 90//计算容量 91privatestaticint calculateCapacity(Object[] elementData, int minCapacity) {//elementData=[1,2,3],minCapacity=4
 92//如果元素数组等于默认容量的元素数组，就返回DEFAULT_CAPACITY和minCapacity两者的最大值 93if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
 94return Math.max(DEFAULT_CAPACITY, minCapacity);
 95        }
 96//否则就返回minCapacity 97return minCapacity; //4 98    }
 99100privatevoid ensureExplicitCapacity(int minCapacity) { //minCapacity=4101         modCount++;
102103// overflow-conscious code104/*105        这里有两种情况：
106            情况一：elementData为空数组，minCapacity=size+1=1,1-0>0,调用grow()进行扩容
107            情况二：elementData不为空数组，minCapacity=size+1，为elementData原始的数组(未调用add方法前)，
108                    如果length不够用，再调用grow()进行扩容
109*/110if (minCapacity - elementData.length > 0)
111            grow(minCapacity);
112    }
113114/**115     * 增加容量以确保它至少可以容纳由最小容量参数指定的元素数
116     * Increases the capacity to ensure that it can hold at least the
117     * number of elements specified by the minimum capacity argument.
118     *
119     * @param minCapacity the desired minimum capacity
120*/121privatevoid grow(int minCapacity) {
122// overflow-conscious code
123//将原始的elementData.length赋给oldCapacity124int oldCapacity = elementData.length;
125//新容量=1.5*oldCapacity126int newCapacity = oldCapacity + (oldCapacity >> 1);
127//如果elementData为空数组，那么oldCapacity和newCapacity都为0，将newCapacity直接赋值为10128if (newCapacity - minCapacity < 0)
129             newCapacity = minCapacity;
130//如果newCapacity超过了最大的容量限制，将调用hugeCapacity()做进一步处理131if (newCapacity - MAX_ARRAY_SIZE > 0)
132             newCapacity = hugeCapacity(minCapacity);
133// minCapacity is usually close to size, so this is a win:
134//newCapacity确定好了以后，就copyof数组，进行扩容135         elementData = Arrays.copyOf(elementData, newCapacity);
136    }
137138privatestaticint hugeCapacity(int minCapacity) {
139if (minCapacity < 0) // overflow140thrownew OutOfMemoryError();
141//判断minCapacity是否大于最大的数组容量MAX_ARRAY_SIZE:是，返回Integer.MAX_VALUE(2147483647);
142//否则返回MAX_ARRAY_SIZE143return (minCapacity > MAX_ARRAY_SIZE) ?
144            Integer.MAX_VALUE :
145            MAX_ARRAY_SIZE;
146    }
147148/**149     * 在指定位置插入元素
150     * Inserts the specified element at the specified position in this
151     * list. Shifts the element currently at that position (if any) and
152     * any subsequent elements to the right (adds one to their indices).
153     *
154     * @param index index at which the specified element is to be inserted
155     * @param element element to be inserted
156     * @throws IndexOutOfBoundsException {@inheritDoc}
157*/158publicvoid add(int index, E element) {
159//检查插入的位置是否合理160        rangeCheckForAdd(index);
161162//插入元素之后，将index之后的元素都往后移一位163         ensureCapacityInternal(size + 1);  // Increments modCount!!164         System.arraycopy(elementData, index, elementData, index + 1,
165                          size - index);
166         elementData[index] = element;
167         size++;
168    }
169170/**171     * 用于add和addAll方法的范围检查
172     * A version of rangeCheck used by add and addAll.
173*/174privatevoid rangeCheckForAdd(int index) {
175if (index > size || index < 0)
176thrownew IndexOutOfBoundsException(outOfBoundsMsg(index));
177    }
178179/**180     * 删除指定位置的元素
181     * Removes the element at the specified position in this list.
182     * Shifts any subsequent elements to the left (subtracts one from their
183     * indices).
184     *
185     * @param index the index of the element to be removed
186     * @return the element that was removed from the list
187     * @throws IndexOutOfBoundsException {@inheritDoc}
188*/189public E remove(int index) {
190//范围检查191        rangeCheck(index);
192193         modCount++;
194         E oldValue = elementData(index); //要删除指定index位置的值
195196//计算要移动的位数197int numMoved = size - index - 1;
198if (numMoved > 0)
199/*200            public static native void arraycopy(Object src,  int  srcPos,
201                                        Object dest, int destPos,
202                                        int length);
203            Copies an array from the specified source array, beginning at the
204            specified position, to the specified position of the destination array.                            
205            从源数组的特殊位置开始拷贝到目标数组的特定位置
206207            System.arraycopy(elementData, index+1, elementData, index,
208                             size - index - 1);    //size=8，index=5，8-5-1=2，src=[1,2,3,4,5,7,8]
209*/210             System.arraycopy(elementData, index+1, elementData, index,
211                             numMoved);
212         elementData[--size] = null; // clear to let GC do its work213214return oldValue;
215    }
216217/**218     * 移除list列表中第一次出现的待删除的元素
219     * Removes the first occurrence of the specified element from this list,
220     * if it is present.  If the list does not contain the element, it is
221     * unchanged.  More formally, removes the element with the lowest index
222     * <tt>i</tt> such that
223     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
224     * (if such an element exists).  Returns <tt>true</tt> if this list
225     * contained the specified element (or equivalently, if this list
226     * changed as a result of the call).
227     *
228     * @param o element to be removed from this list, if present
229     * @return <tt>true</tt> if this list contained the specified element
230*/231publicboolean remove(Object o) {
232//依次遍历删除233if (o == null) {
234for (int index = 0; index < size; index++)
235if (elementData[index] == null) {
236                    fastRemove(index);
237returntrue;
238                }
239         } else {
240for (int index = 0; index < size; index++)
241if (o.equals(elementData[index])) {
242                    fastRemove(index);
243returntrue;
244                }
245        }
246returnfalse;
247    }
248//remove函数用户移除指定下标的元素，此时会把指定下标到数组末尾的元素向前移动一个单位，
249//并把最后一个元素置为null250251/**252     * 将list表中指定位置的元素替换掉
253     * Replaces the element at the specified position in this list with
254     * the specified element.
255     *
256     * @param index index of the element to replace
257     * @param element element to be stored at the specified position
258     * @return the element previously at the specified position
259     * @throws IndexOutOfBoundsException {@inheritDoc}
260*/261public E set(int index, E element) {
262//范围检查263        rangeCheck(index);
264265//指定位置的元素值266         E oldValue = elementData(index);
267//将elementData的指定位置替换为element268         elementData[index] = element;
269return oldValue;
270    }
271272/**273     * 返回在list列表中的指定元素第一次出现的索引值
274     * Returns the index of the first occurrence of the specified element
275     * in this list, or -1 if this list does not contain the element.
276     * More formally, returns the lowest index <tt>i</tt> such that
277     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
278     * or -1 if there is no such index.
279*/280publicint indexOf(Object o) {
281if (o == null) {
282for (int i = 0; i < size; i++)
283if (elementData[i]==null)
284return i;
285         } else {
286for (int i = 0; i < size; i++)
287if (o.equals(elementData[i]))
288return i;
289        }
290return -1;
291    }
292//从头开始查找元素，可以查找null值293294/**295     * 返回在list列表中指定位置的元素
296     * Returns the element at the specified position in this list.
297     *
298     * @param  index index of the element to return
299     * @return the element at the specified position in this list
300     * @throws IndexOutOfBoundsException {@inheritDoc}
301*/302public E get(int index) {
303//范围检查，只检查>=size的部分304        rangeCheck(index);
305306return elementData(index);
307    }
308309     E elementData(int index) {
310return (E) elementData[index];
311    }
312//注意：返回的值都做了向下转型（object->E）处理313 }