ArrayList源码分析（二）--方法

长篇警告，善用 ctrl+f（搜索）

/**
     * Trims the capacity of this ArrayList instance to be the
     * list's current size.  An application can use this operation to minimize
     * the storage of an ArrayList instance.
     *调整数组大小到现在存储的元素个数，如果个数为0则赋给 EMPTY_ELEMENTDATA
     *不然返回elementData元素个数大小的数组
     */
      
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }
     
   /**
     * Returns the number of elements in this list.
     *
     * @return the number of elements in this list
     *返回元素个数
     */
    public int size() {
        return size;
    }
     
    /**
     * Returns true if this list contains no elements.
     *
     * @return true if this list contains no elements
     *如果没有元素返回false
     */
      
    public boolean isEmpty() {
        return size == 0;
    }
     
    /**
     * Returns true if this list contains the specified element.
     * More formally, returns true if and only if this list contains
     * at least one element e such that
     * (o==null ? e==null : o.equals(e)).
     *
     * @param o element whose presence in this list is to be tested
     * @return true if this list contains the specified element
     *调用indexOf(o)方法看是否包含某个元素,
     *indexOf(o)返回元素的位置，没有找到则返回-1 
     */
    public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
     
    /**
     * Returns the index of the first occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     * More formally, returns the lowest index i such that
     * (o==null ? get(i)==null : o.equals(get(i))),
     * or -1 if there is no such index.
     *将传进来的对象与数组内的对象比较，相等即找到，返回元素位置
     *搜索从0开始，返回最先找到的那个元素
     */
    public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
     
    /**
     * Returns the index of the last occurrence of the specified element
     * in this list, or -1 if this list does not contain the element.
     * More formally, returns the highest index i such that
     * (o==null ? get(i)==null : o.equals(get(i))),
     * or -1 if there is no such index.
     *跟上面的一样，只是搜索从size-1开始，即返回位置上最后找到的那个元素
     */
    public int lastIndexOf(Object o) {
        if (o == null) {
            for (int i = size-1; i >= 0; i--)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = size-1; i >= 0; i--)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
     
    /**
     * Returns a shallow copy of this ArrayList instance.  (The
     * elements themselves are not copied.)
     *
     * @return a clone of this ArrayList instance
     *返回对象浅拷贝，这个我没涉及过
     *之后我会补一篇深拷贝和浅拷贝区别的文章
     */
    public Object clone() {
        try {
            ArrayList v = (ArrayList) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }
     
    /**
     * Returns an array containing all of the elements in this list
     * in proper sequence (from first to last element).
     *
     * 
The returned array will be "safe" in that no references to it are
     * maintained by this list.  (In other words, this method must allocate
     * a new array).  The caller is thus free to modify the returned array.
     *
     * 
This method acts as bridge between array-based and collection-based
     * APIs.
     *
     * @return an array containing all of the elements in this list in
     *         proper sequence
     *返回包含了全部元素的对象数组
     */
    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }
     
    /**
     * Returns an array containing all of the elements in this list in proper
     * sequence (from first to last element); the runtime type of the returned
     * array is that of the specified array.  If the list fits in the
     * specified array, it is returned therein.  Otherwise, a new array is
     * allocated with the runtime type of the specified array and the size of
     * this list.
     *
     * 
If the list fits in the specified array with room to spare
     * (i.e., the array has more elements than the list), the element in
     * the array immediately following the end of the collection is set to
     * null.  (This is useful in determining the length of the
     * list only if the caller knows that the list does not contain
     * any null elements.)
     *
     * @param a the array into which the elements of the list are to
     *          be stored, if it is big enough; otherwise, a new array of the
     *          same runtime type is allocated for this purpose.
     * @return an array containing the elements of the list
     * @throws ArrayStoreException if the runtime type of the specified array
     *         is not a supertype of the runtime type of every element in
     *         this list
     * @throws NullPointerException if the specified array is null
     *这个方法是上诉方法的升级版，返回特定类型的数组
     *当ArrayList元素个数大于传进的数组大小时，返回包含ArrayList元素的数组
     *当传进的数组大小大于ArrayList元素个数，直接赋予null值
     */
    @SuppressWarnings("unchecked")
    public  T[] toArray(T[] a) {
        if (a.length < size)
            // Make a new array of a's runtime type, but my contents:
            return (T[]) Arrays.copyOf(elementData, size, a.getClass());
        System.arraycopy(elementData, 0, a, 0, size);
        if (a.length > size)
            a[size] = null;
        return a;
    }
    // Positional Access Operations
    //取出index位置的数组元素，别忘了elementData是个对象数组
     @SuppressWarnings("unchecked")
    E elementData(int index) {
        return (E) elementData[index];
    }
     
    /**
     * Returns the element at the specified position in this list.
     *
     * @param  index index of the element to return
     * @return the element at the specified position in this list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * rangeCheck方法判断index是否越界，没有则返回index位置的数组元素
     */
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
     
    /**
     * Replaces the element at the specified position in this list with
     * the specified element.
     *
     * @param index index of the element to replace
     * @param element element to be stored at the specified position
     * @return the element previously at the specified position
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * rangeCheck判断是否越界，将新值赋给elementData[index]，返回旧值
     */
    public E set(int index, E element) {
        rangeCheck(index);
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
     
    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return true (as specified by {@link Collection#add})
     * 在后面追加一个元素，追加之前判断是否需要扩容
     */
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
     
    /**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * 在指定位置添加元素，如果指定位置有元素，则把原元素后（右）移
     * rangeCheckForAdd判断要加的位置是否越界
     * arraycopy(Object src,  int  srcPos, Object dest, int destPos,int length);参数解释如下：
     * 1.源数组，2.要复制的头元素位置，3.目标数组，4.要复制到的位置，5.要复制的长度
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
     
    /**
     * Removes the element at the specified position in this list.
     * Shifts any subsequent elements to the left (subtracts one from their
     * indices).
     *
     * @param index the index of the element to be removed
     * @return the element that was removed from the list
     * @throws IndexOutOfBoundsException {@inheritDoc}
     *移除特定位置的一个元素，如果移除是最后一个元素，直接将elementData[last]赋为空等GC清理,size-1
     *不然把数组向前（左）移，提醒：size比最后一个数组元素大1
     */
    public E remove(int index) {
        rangeCheck(index);
        modCount++;
        E oldValue = elementData(index);
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
        return oldValue;
    }
     
    /**
     * Removes the first occurrence of the specified element from this list,
     * if it is present.  If the list does not contain the element, it is
     * unchanged.  More formally, removes the element with the lowest index
     * i such that
     * (o==null ? get(i)==null : o.equals(get(i)))
     * (if such an element exists).  Returns true if this list
     * contained the specified element (or equivalently, if this list
     * changed as a result of the call).
     *
     * @param o element to be removed from this list, if present
     * @return true if this list contained the specified element
     *移除最近一个匹配到的对象，调用fastRemove移除，无匹配返回false
     */
    public boolean remove(Object o) {
        if (o == null) {
            for (int index = 0; index < size; index++)
                if (elementData[index] == null) {
                    fastRemove(index);
                    return true;
                }
        } else {
            for (int index = 0; index < size; index++)
                if (o.equals(elementData[index])) {
                    fastRemove(index);
                    return true;
                }
        }
        return false;
    }
     
    /*
     * Private remove method that skips bounds checking and does not
     * return the value removed.
     *如果移除的是最后一个，直接把elementData[last]赋值null,size-1，否则移动
     */
    private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }
     
    /**
     * Removes all of the elements from this list.  The list will
     * be empty after this call returns.
     *将elementData数组元素全部赋值null,size=0
     */
    public void clear() {
        modCount++;
        // clear to let GC do its work
        for (int i = 0; i < size; i++)
            elementData[i] = null;
        size = 0;
    }
     
    /**
     * Appends all of the elements in the specified collection to the end of
     * this list, in the order that they are returned by the
     * specified collection's Iterator.  The behavior of this operation is
     * undefined if the specified collection is modified while the operation
     * is in progress.  (This implies that the behavior of this call is
     * undefined if the specified collection is this list, and this
     * list is nonempty.)
     *
     * @param c collection containing elements to be added to this list
     * @return true if this list changed as a result of the call
     * @throws NullPointerException if the specified collection is null
     * 将Collection.toArray()返回的对象数组追加到原数组后面，
     * 如果Collection里面没有元素(a.length=0)，返回flase
     */
    public boolean addAll(Collection c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }
     
    /**
     * Inserts all of the elements in the specified collection into this
     * list, starting at the specified position.  Shifts the element
     * currently at that position (if any) and any subsequent elements to
     * the right (increases their indices).  The new elements will appear
     * in the list in the order that they are returned by the
     * specified collection's iterator.
     *
     * @param index index at which to insert the first element from the
     *              specified collection
     * @param c collection containing elements to be added to this list
     * @return true if this list changed as a result of the call
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @throws NullPointerException if the specified collection is null
     * 上面方法的指定位置版，判断一下要移动的元素个数，然后后（右）移给要插入的数组让位
     */
    public boolean addAll(int index, Collection c) {
        rangeCheckForAdd(index);
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);
        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }
     
    /**
     * Removes from this list all of the elements whose index is between
     * {@code fromIndex}, inclusive, and {@code toIndex}, exclusive.
     * Shifts any succeeding elements to the left (reduces their index).
     * This call shortens the list by {@code (toIndex - fromIndex)} elements.
     * (If {@code toIndex==fromIndex}, this operation has no effect.)
     *
     * @throws IndexOutOfBoundsException if {@code fromIndex} or
     *         {@code toIndex} is out of range
     *         ({@code fromIndex < 0 ||
     *          fromIndex >= size() ||
     *          toIndex > size() ||
     *          toIndex < fromIndex})
     * 删除动态数组中从 fromIndex 到 toIndex 中的元素（不包括toIndex）
     * 先算出要删除的个数，然后从elementData[toIndex]开始覆盖掉elementData[fromIndex]以及后面的元素
     */
    protected void removeRange(int fromIndex, int toIndex) {
        modCount++;
        int numMoved = size - toIndex;
        System.arraycopy(elementData, toIndex, elementData, fromIndex,
                         numMoved);
        // clear to let GC do its work
        int newSize = size - (toIndex-fromIndex);
        for (int i = newSize; i < size; i++) {
            elementData[i] = null;
        }
        size = newSize;
    }
     
    /**
     * Checks if the given index is in range.  If not, throws an appropriate
     * runtime exception.  This method does *not* check if the index is
     * negative: It is always used immediately prior to an array access,
     * which throws an ArrayIndexOutOfBoundsException if index is negative.
     * 判断index是否越界，这个非add方法调用，所以不能等于size
     */
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
     
    /**
     * A version of rangeCheck used by add and addAll.
     * 判断index是否越界，这个是add方法调用，可以等于size
     */
    private void rangeCheckForAdd(int index) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    /**
     * Constructs an IndexOutOfBoundsException detail message.
     * Of the many possible refactorings of the error handling code,
     * this "outlining" performs best with both server and client VMs.
     * 报异常的提示信息，提示index的大小和Arraylist的大小
     */
    private String outOfBoundsMsg(int index) {
        return "Index: "+index+", Size: "+size;
    }
     
    /**
     * Removes from this list all of its elements that are contained in the
     * specified collection.
     *
     * @param c collection containing elements to be removed from this list
     * @return {@code true} if this list changed as a result of the call
     * @throws ClassCastException if the class of an element of this list
     *         is incompatible with the specified collection
     * (optional)
     * @throws NullPointerException if this list contains a null element and the
     *         specified collection does not permit null elements
     * (optional),
     *         or if the specified collection is null
     * @see Collection#contains(Object)
     * 移除传进的集合包含的元素
     */
    public boolean removeAll(Collection c) {
        Objects.requireNonNull(c);
        return batchRemove(c, false);
    }
     
    /**
     * Retains only the elements in this list that are contained in the
     * specified collection.  In other words, removes from this list all
     * of its elements that are not contained in the specified collection.
     *
     * @param c collection containing elements to be retained in this list
     * @return {@code true} if this list changed as a result of the call
     * @throws ClassCastException if the class of an element of this list
     *         is incompatible with the specified collection
     * (optional)
     * @throws NullPointerException if this list contains a null element and the
     *         specified collection does not permit null elements
     * (optional),
     *         or if the specified collection is null
     * @see Collection#contains(Object)
     * 跟上面的方法相反，移除传进来的集合里不包含的元素，
     */
    public boolean retainAll(Collection c) {
        Objects.requireNonNull(c);
        return batchRemove(c, true);
    }

/**
    *感觉这个有点难理解，我们要考虑两种情况，complement是true还是false
    * 当为true时，如果c中包含elementData[r]，将elementData[r]赋给elementData[w++]，即覆盖掉不存在的元素 
    * 当为flase时，如果c中不包含elementData[r]，将elementData[r]赋给elementData[w++]，即覆盖掉存在的元素
    * 下面的 r != size 原注释说防止抛出异常，我也不太清楚怎样才能触发这个异常
    * 再下面的 w != size 时则有元素移除了，把后面的元素赋为null
    */
    private boolean batchRemove(Collection c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }
     
    /**
     * Save the state of the ArrayList instance to a stream (that
     * is, serialize it).
     *
     * @serialData The length of the array backing the ArrayList
     *             instance is emitted (int), followed by all of its elements
     *             (each an Object) in the proper order.
     * 保存ArrayList状态到输出流，写的东西有size，和数组里的全部元素
     */
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);
        // Write out all elements in the proper order.
        for (int i=0; iArrayList instance from a stream (that is,
     * deserialize it).
     * 把输出流里的内容赋给a数组
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;
        // Read in size, and any hidden stuff
        s.defaultReadObject();
        // Read in capacity
        s.readInt(); // ignored
        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);
            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; iThe returned list iterator is fail-fast.
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * 在不越界的时候，返回一个从index开始的list迭代器
     */
    public ListIterator listIterator(int index) {
        if (index < 0 || index > size)
            throw new IndexOutOfBoundsException("Index: "+index);
        return new ListItr(index);
    }
     
    /**
     * Returns a list iterator over the elements in this list (in proper
     * sequence).
     *
     * 
The returned list iterator is fail-fast.
     *
     * @see #listIterator(int)
     * 返回内部类ListItr的迭代器，原注释说这个比AbstractList.ListItr更完善
     * 内部类文章在第三篇
     */
    public ListIterator listIterator() {
        return new ListItr(0);
    }
     
    /**
     * Returns an iterator over the elements in this list in proper sequence.
     *
     * 
The returned iterator is fail-fast.
     *
     * @return an iterator over the elements in this list in proper sequence
     * 返回内部类Itr的迭代器，原注释说这个比AbstractList.Itr更完善
     * 内部类文章在第三篇
     */
    public Iterator iterator() {
        return new Itr();
    }
  
   /**
    * 原注解长得没边我去掉了
    * 这个方法返回一个在指定范围的子List，包含fromIndex,不包含toIndex
    * 如果 fromIndex=toIndex ，返回空list
    * 方法用到了内部类SubList，内部类在第三篇文章
    */
   public List subList(int fromIndex, int toIndex) {
        subListRangeCheck(fromIndex, toIndex, size);
        return new SubList(this, 0, fromIndex, toIndex);
    }
     
   /**
    * 判断是否越界
    */
   static void subListRangeCheck(int fromIndex, int toIndex, int size) {
        if (fromIndex < 0)
            throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
        if (toIndex > size)
            throw new IndexOutOfBoundsException("toIndex = " + toIndex);
        if (fromIndex > toIndex)
            throw new IllegalArgumentException("fromIndex(" + fromIndex +
                                               ") > toIndex(" + toIndex + ")");
    }
     
   /**
    * 参数是函数式编程接口 Consumer 
    * 用处就是可以通过Lambda表达式遍历处理元素
    */
    @Override
    public void forEach(Consumer action) {
        Objects.requireNonNull(action);
        final int expectedModCount = modCount;
        @SuppressWarnings("unchecked")
        final E[] elementData = (E[]) this.elementData;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            action.accept(elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }
     
   /**
    * 方法名是splitable iterator（可分割迭代器）的简写
    * 用处就是可以并行遍历list元素
    * 具体实现是内部类，完全没有信心分析
    */
   @Override
    public Spliterator spliterator() {
        return new ArrayListSpliterator<>(this, 0, -1, 0);
    }
     
   /**
    * 接收一个函数式编程接口 Predicate 参数
    * 当满足Lambda表达式的条件时移除元素，相当于有一层过滤器
    * 这里需要对BigSet.nextClearBit有点概念，简单说就是没有标记返回本值，被标记了返回下一未标记值
    * 例如第4.5.6个元素是要删除的，会被存到BigSet中，调用方法时如果是BigSet.nextClearBit(0-3)则返回0-3
    * 当BigSet.nextClearBit(4)时，返回7
    * 运行过程大概是：1.把满足删除条件的元素位置放到removeSet，2.判断是否有元素要删除
    * 3.通过nextClearBit方法返回下一不需删除元素位置，例如前面的例子，前面几个元素还是放回原位置
    * 从4开始返回7，则elementData[4]=elementData[7];移除了4，5，6中的元素将依次被7，8，9中的代替
    * 4.把多出的长度置为null
    */
   @Override
    public boolean removeIf(Predicate filter) {
        Objects.requireNonNull(filter);
        // figure out which elements are to be removed
        // any exception thrown from the filter predicate at this stage
        // will leave the collection unmodified
        int removeCount = 0;
        final BitSet removeSet = new BitSet(size);
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            @SuppressWarnings("unchecked")
            final E element = (E) elementData[i];
            if (filter.test(element)) {
                removeSet.set(i);
                removeCount++;
            }
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        // shift surviving elements left over the spaces left by removed elements
        final boolean anyToRemove = removeCount > 0;
        if (anyToRemove) {
            final int newSize = size - removeCount;
            for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
                i = removeSet.nextClearBit(i);
                elementData[j] = elementData[i];
            }
            for (int k=newSize; k < size; k++) {
                elementData[k] = null;  // Let gc do its work
            }
            this.size = newSize;
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
            modCount++;
        }
        return anyToRemove;
    }
     
    /**
    * 接收一个函数式编程接口 UnaryOperator 参数
    * 遍历所有元素，将其替换成Lambda表达式的运行结果
    */
    @Override
    @SuppressWarnings("unchecked")
    public void replaceAll(UnaryOperator operator) {
        Objects.requireNonNull(operator);
        final int expectedModCount = modCount;
        final int size = this.size;
        for (int i=0; modCount == expectedModCount && i < size; i++) {
            elementData[i] = operator.apply((E) elementData[i]);
        }
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }
     
    /**
    * 接收一个函数式编程接口 Comparator 参数（也可以用以前的老方法写个内部类）
    * 对list进行排序
    */
    @Override
    @SuppressWarnings("unchecked")
    public void sort(Comparator c) {
        final int expectedModCount = modCount;
        Arrays.sort((E[]) elementData, 0, size, c);
        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
        modCount++;
    }

专业的博客就是厉害，可以保存的字数再多也不怕，在我的博客中，这篇文章分为两篇：

上篇：http://jimblog.site/blog/articles/89.html

下篇：http://jimblog.site/blog/articles/90.html