JDK1.8源码ArrayList

线程不安全的，如果要想线程安全必须在创建的时候就采用线程安全的方式创建：

 List list = Collections.synchronizedList(new ArrayList(...));

引用博文链接 ： http://www.cnblogs.com/leskang/p/6019887.html

构造器：

 public class ArrayList<E> extends AbstractList<E>
         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
 {
     private static final long serialVersionUID = 8683452581122892189L;

     //默认初始大小：10
     private static final int DEFAULT_CAPACITY = 10;
       //记录列表结构性修改次数，next,add，remove,previous,set操作
     protected transient int modCount = 0;
     //空数组
     private static final Object[] EMPTY_ELEMENTDATA = {};

     //默认大小空数组
     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

     transient Object[] elementData; // non-private to simplify nested class access

     private int size;

     //构建一个大小指定的空列表
     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);
         }
     }

     //构建一个默认大小（10）的空列表
     public ArrayList() {
         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
     }

     //构建一个包含集合元素的列表，元素排列顺序是按集合的迭代器返回的顺序
     public ArrayList(Collection<? extends E> c) {
         elementData = c.toArray();
         if ((size = elementData.length) != 0) {
             // c.toArray might (incorrectly) not return Object[] (see 6260652)
             if (elementData.getClass() != Object[].class)
                 elementData = Arrays.copyOf(elementData, size, Object[].class);
         } else {
             // replace with empty array.
             this.elementData = EMPTY_ELEMENTDATA;
         }
     }
   ......
 }

boolean add(E e)：

 1     public boolean add(E e) {
         ensureCapacityInternal(size + 1);  // Increments modCount!! // 添加之前检查数组容量，size+1表示接下来要有的容量
         elementData[size++] = e;　　
         return true;
     }

     private void ensureCapacityInternal(int minCapacity) {
         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//如果elementData 为空集合
             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);//将传入的minCapacity和默认值10比较，选出较大的
         }

         ensureExplicitCapacity(minCapacity);
     }

     private void ensureExplicitCapacity(int minCapacity) {
         modCount++;

         // overflow-conscious code
         if (minCapacity - elementData.length > 0)//如果最小容量大于列表现有的长度，则扩容，否则容量不变
             grow(minCapacity);
     }

     private void grow(int minCapacity) {
         // overflow-conscious code
         int oldCapacity = elementData.length;
         int newCapacity = oldCapacity + (oldCapacity >> 1);//>> : 右移运算符，num >> 1,相当于num除以2,此处扩容按照原容量大小的一半扩容
         if (newCapacity - minCapacity < 0)
             newCapacity = minCapacity;
         if (newCapacity - MAX_ARRAY_SIZE > 0)//如果新容量大于integer的最大值
             newCapacity = hugeCapacity(minCapacity);
         // minCapacity is usually close to size, so this is a win:
         elementData = Arrays.copyOf(elementData, newCapacity); //将原有元素拷贝到扩容后的新数组中
     }

      private static int hugeCapacity(int minCapacity) {
         if (minCapacity < 0) // overflow
             throw new OutOfMemoryError();
         return (minCapacity > MAX_ARRAY_SIZE) ?   //如果新容量大于（integer的最大值-8），最大容量就是integer的最大值
             Integer.MAX_VALUE :
             MAX_ARRAY_SIZE;
     }

总结：ArrayList列表的最大容量就integer的最大值

 

 E remove(int index)：

   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 将最后一个元素置null回收

         return oldValue;
     }

     //System类的方法，从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
     从 src 引用的源数组到 dest 引用的目标数组，数组组件的一个子序列被复制下来。被复制的组件的编号等于 length 参数。
18     源数组中位置在 srcPos 到 srcPos+length-1 之间的组件被分别复制到目标数组中的 destPos 到 destPos+length-1 位置。
19     即目标数组的后半段被原数组的后半段（去掉要移除部分）
     public static native void arraycopy(Object src,  int  srcPos,
                                         Object dest, int destPos,
                                         int length);

add(int index, E element)：

  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;//index的位置置为element
         size++;
     }

总结：ArrayList增删比较慢

addAll：

      public boolean addAll(Collection<? extends E> 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;
      }

     public boolean addAll(int index, Collection<? extends E> c) {
         rangeCheckForAdd(index);

         Object[] a = c.toArray();
         int numNew = a.length;
         ensureCapacityInternal(size + numNew);  // Increments modCount

         int numMoved = size - index;
         if (numMoved > 0) //如果是列表中间位置插入，先将列表index到index+numNew之间的位置空出来
             System.arraycopy(elementData, index, elementData, index + numNew,
                              numMoved);

         System.arraycopy(a, 0, elementData, index, numNew);//将新添加的元素添加到空出的位置，这里省了一个numMoved==0的判断
         size += numNew;
         return numNew != 0;
     }

     //检查脚标是否越界
     private void rangeCheckForAdd(int index) {
         if (index > size || index < 0)
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

boolean remove(Object o)：

  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;
     }

     //此方法和remove类似，没有检查索引是否越界
     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
     }

总结：先判断是否是null，如果是要单独操作；否则通过逐个比较元素来判断要移除元素的位置，再通过类似于remove的方法移除元素

E set(int index, E element)：修改

     public E set(int index, E element) {
         rangeCheck(index);

         E oldValue = elementData(index);
         elementData[index] = element;
         return oldValue;
     }

总结：直接替换指定位置的元素

E get(int index)：

     public E get(int index) {
         rangeCheck(index);

         return elementData(index);
     }

     @SuppressWarnings("unchecked")
     E elementData(int index) {
         return (E) elementData[index];
     }

总结：根据数组脚标拿到元素，所以速度快

其他一些方法 ：

     //修剪列表的容量到最小值，
     public void trimToSize() {
         modCount++;
         if (size < elementData.length) {
             elementData = (size == 0) //如果size==0，容量是默认值10，
               ? EMPTY_ELEMENTDATA
               : Arrays.copyOf(elementData, size);//否则将数组拷贝到一个新的数组（长度为size）
         }
     }

     //确保列表容量增加到minCapacity
     public void ensureCapacity(int minCapacity) {
         //如果列表为DEFAULTCAPACITY_EMPTY_ELEMENTDATA，即空列表，则列表容量为默认值10，
         否则为0
         int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
             // any size if not default element table
             ? 0
             // larger than default for default empty table. It's already
             // supposed to be at default size.
             : DEFAULT_CAPACITY;

         if (minCapacity > minExpand) {
             ensureExplicitCapacity(minCapacity);
         }
     }

     //判断列表元素个数是否为0
     public boolean isEmpty() {
         return size == 0;
     }

     public boolean contains(Object o) {
         return indexOf(o) >= 0;
     }

     //判断元素o在列表里存在的位置，如果存在返回index，如果不存在返回-1
     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;
     }

     //判断元素o最后一次出现的位置，如果存在返回index，如果不存在返回-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;
     }

     //克隆浅表副本
     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);
         }
     }

     // 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
       由于此列表不维护对返回数组的任何引用，因而它将是“安全的”。
      （换句话说，此方法必须分配一个新的数组）。因此，调用者可以自由地修改返回的数组。
       此方法担当基于数组的 API 和基于 collection 的 API 之间的桥梁。
     public Object[] toArray() {
         return Arrays.copyOf(elementData, size);
     }

     public <T> 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;
     }

    //清空列表
     public void clear() {
         modCount++;

         // clear to let GC do its work
         for (int i = 0; i < size; i++)
             elementData[i] = null;

         size = 0;
     }

     //删除fromIndex（包含）到toIndex（不包含）之间的元素
     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;
     }

     //检测脚标是否越界
     private void rangeCheck(int index) {
         if (index >= size)
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     private String outOfBoundsMsg(int index) {
         return "Index: "+index+", Size: "+size;
     }

      */
     //移除与集合c里相同的元素
     public boolean removeAll(Collection<?> c) {
         Objects.requireNonNull(c);
         return batchRemove(c, false);
     }

     //保留与集合c里相同的元素
     public boolean retainAll(Collection<?> c) {
         Objects.requireNonNull(c);
         return batchRemove(c, true);
     }

     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;
     }

     //序列化列表
     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; i<size; i++) {
             s.writeObject(elementData[i]);    //ArrayList的设计者将elementData设计为transient，
             然后在writeObject方法中手动将其序列化，并且只序列化了实际存储的那些元素，而不是整个数组。
         }

         if (modCount != expectedModCount) {
             throw new ConcurrentModificationException();
         }
     }

     //反序列化列表
     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; i<size; i++) {
                 a[i] = s.readObject();
             }
         }
     }

Iterator<E> iterator()，ListIterator<E> listIterator(int index) 与LinkedList类似：可参考  https://www.cnblogs.com/sqy123/p/9272666.html

还有Spliterator 

     public Iterator<E> iterator() {
         return new Itr();
     }

     private class Itr implements Iterator<E> {
         int cursor;       // index of next element to return
         int lastRet = -1; // index of last element returned; -1 if no such
         int expectedModCount = modCount;

         public boolean hasNext() {
             return cursor != size;
         }

         @SuppressWarnings("unchecked")
         public E next() {
             checkForComodification();
             int i = cursor;
             if (i >= size)
                 throw new NoSuchElementException();
             Object[] elementData = ArrayList.this.elementData;
             if (i >= elementData.length)
                 throw new ConcurrentModificationException();
             cursor = i + 1;
             return (E) elementData[lastRet = i];
         }

         public void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();

             try {
                 ArrayList.this.remove(lastRet);
                 cursor = lastRet;
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }

         //外部结构修改则迭代快速失败fast-fails
         @Override
         @SuppressWarnings("unchecked")
         public void forEachRemaining(Consumer<? super E> consumer) {
             Objects.requireNonNull(consumer);
             final int size = ArrayList.this.size;
             int i = cursor;
             if (i >= size) {
                 return;
             }
             final Object[] elementData = ArrayList.this.elementData;
             if (i >= elementData.length) {
                 throw new ConcurrentModificationException();
             }
             while (i != size && modCount == expectedModCount) {
                 consumer.accept((E) elementData[i++]);
             }
             // update once at end of iteration to reduce heap write traffic
             cursor = i;
             lastRet = i - 1;
             checkForComodification();
         }

         final void checkForComodification() {
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
         }
     }

      //返回此列表中的元素的列表迭代器（按适当顺序:从列表中指定位置开始）
     public ListIterator<E> listIterator(int index) {
         if (index < 0 || index > size)
             throw new IndexOutOfBoundsException("Index: "+index);
         return new ListItr(index); //调用内部类ListItr的匿名对象
     }

     public ListIterator<E> listIterator() {
         return new ListItr(0);
     }

     private class ListItr extends Itr implements ListIterator<E> {
         ListItr(int index) {
             super();
             cursor = index;
         }

         public boolean hasPrevious() {
             return cursor != 0;
         }

         public int nextIndex() {
             return cursor;
         }

         public int previousIndex() {
             return cursor - 1;
         }

         @SuppressWarnings("unchecked")
         public E previous() {
             checkForComodification();
             int i = cursor - 1;
             if (i < 0)
                 throw new NoSuchElementException();
             Object[] elementData = ArrayList.this.elementData;
             if (i >= elementData.length)
                 throw new ConcurrentModificationException();
             cursor = i;
             return (E) elementData[lastRet = i];
         }

         public void set(E e) {
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();

             try {
                 ArrayList.this.set(lastRet, e);
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }

         public void add(E e) {
             checkForComodification();

             try {
                 int i = cursor;
                 ArrayList.this.add(i, e);
                 cursor = i + 1;
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }
     }

 List<E> subList(int fromIndex, int toIndex)：

对原来的list和返回的sublist做的“非结构性修改”(non-structural changes)，都会影响到彼此对方。

所谓的“非结构性修改”，是指不涉及到list的大小改变的修改。相反，结构性修改，指改变了list大小的修改。

博文链接：https://blog.csdn.net/leisurelen/article/details/51174614

     //获取子列表（包括fromIndex，不包括toIndex）
     public List<E> 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 + ")");
     }

     private class SubList extends AbstractList<E> implements RandomAccess {
         private final AbstractList<E> parent;
         private final int parentOffset;
         private final int offset;
         int size;

         SubList(AbstractList<E> parent,
                 int offset, int fromIndex, int toIndex) {
             this.parent = parent;
             this.parentOffset = fromIndex;
             this.offset = offset + fromIndex;
             this.size = toIndex - fromIndex;
             this.modCount = ArrayList.this.modCount;
         }

         public E set(int index, E e) {
             rangeCheck(index);
             checkForComodification();
             E oldValue = ArrayList.this.elementData(offset + index);
             ArrayList.this.elementData[offset + index] = e;
             return oldValue;
         }

         public E get(int index) {
             rangeCheck(index);
             checkForComodification();
             return ArrayList.this.elementData(offset + index);
         }

         public int size() {
             checkForComodification();
             return this.size;
         }

         public void add(int index, E e) {
             rangeCheckForAdd(index);
             checkForComodification();
             parent.add(parentOffset + index, e);
             this.modCount = parent.modCount;
             this.size++;
         }

         public E remove(int index) {
             rangeCheck(index);
             checkForComodification();
             E result = parent.remove(parentOffset + index);
             this.modCount = parent.modCount;
             this.size--;
             return result;
         }

         protected void removeRange(int fromIndex, int toIndex) {
             checkForComodification();
             parent.removeRange(parentOffset + fromIndex,
                                parentOffset + toIndex);
             this.modCount = parent.modCount;
             this.size -= toIndex - fromIndex;
         }

         public boolean addAll(Collection<? extends E> c) {
             return addAll(this.size, c);
         }

         public boolean addAll(int index, Collection<? extends E> c) {
             rangeCheckForAdd(index);
             int cSize = c.size();
             if (cSize==0)
                 return false;

             checkForComodification();
             parent.addAll(parentOffset + index, c);
             this.modCount = parent.modCount;
             this.size += cSize;
             return true;
         }

         public Iterator<E> iterator() {
             return listIterator();
         }

         public ListIterator<E> listIterator(final int index) {
             checkForComodification();
             rangeCheckForAdd(index);
             final int offset = this.offset;

             return new ListIterator<E>() {
                 int cursor = index;
                 int lastRet = -1;
                 int expectedModCount = ArrayList.this.modCount;

                 public boolean hasNext() {
                     return cursor != SubList.this.size;
                 }

                 @SuppressWarnings("unchecked")
                 public E next() {
                     checkForComodification();
                     int i = cursor;
                     if (i >= SubList.this.size)
                         throw new NoSuchElementException();
                     Object[] elementData = ArrayList.this.elementData;
                     if (offset + i >= elementData.length)
                         throw new ConcurrentModificationException();
                     cursor = i + 1;
                     return (E) elementData[offset + (lastRet = i)];
                 }

                 public boolean hasPrevious() {
                     return cursor != 0;
                 }

                 @SuppressWarnings("unchecked")
                 public E previous() {
                     checkForComodification();
                     int i = cursor - 1;
                     if (i < 0)
                         throw new NoSuchElementException();
                     Object[] elementData = ArrayList.this.elementData;
                     if (offset + i >= elementData.length)
                         throw new ConcurrentModificationException();
                     cursor = i;
                     return (E) elementData[offset + (lastRet = i)];
                 }

                 @SuppressWarnings("unchecked")
                 public void forEachRemaining(Consumer<? super E> consumer) {
                     Objects.requireNonNull(consumer);
                     final int size = SubList.this.size;
                     int i = cursor;
                     if (i >= size) {
                         return;
                     }
                     final Object[] elementData = ArrayList.this.elementData;
                     if (offset + i >= elementData.length) {
                         throw new ConcurrentModificationException();
                     }
                     while (i != size && modCount == expectedModCount) {
                         consumer.accept((E) elementData[offset + (i++)]);
                     }
                     // update once at end of iteration to reduce heap write traffic
                     lastRet = cursor = i;
                     checkForComodification();
                 }

                 public int nextIndex() {
                     return cursor;
                 }

                 public int previousIndex() {
                     return cursor - 1;
                 }

                 public void remove() {
                     if (lastRet < 0)
                         throw new IllegalStateException();
                     checkForComodification();

                     try {
                         SubList.this.remove(lastRet);
                         cursor = lastRet;
                         lastRet = -1;
                         expectedModCount = ArrayList.this.modCount;
                     } catch (IndexOutOfBoundsException ex) {
                         throw new ConcurrentModificationException();
                     }
                 }

                 public void set(E e) {
                     if (lastRet < 0)
                         throw new IllegalStateException();
                     checkForComodification();

                     try {
                         ArrayList.this.set(offset + lastRet, e);
                     } catch (IndexOutOfBoundsException ex) {
                         throw new ConcurrentModificationException();
                     }
                 }

                 public void add(E e) {
                     checkForComodification();

                     try {
                         int i = cursor;
                         SubList.this.add(i, e);
                         cursor = i + 1;
                         lastRet = -1;
                         expectedModCount = ArrayList.this.modCount;
                     } catch (IndexOutOfBoundsException ex) {
                         throw new ConcurrentModificationException();
                     }
                 }

                 final void checkForComodification() {
                     if (expectedModCount != ArrayList.this.modCount)
                         throw new ConcurrentModificationException();
                 }
             };
         }

         public List<E> subList(int fromIndex, int toIndex) {
             subListRangeCheck(fromIndex, toIndex, size);
             return new SubList(this, offset, fromIndex, toIndex);
         }

         private void rangeCheck(int index) {
             if (index < 0 || index >= this.size)
                 throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
         }

         private void rangeCheckForAdd(int index) {
             if (index < 0 || index > this.size)
                 throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
         }

         private String outOfBoundsMsg(int index) {
             return "Index: "+index+", Size: "+this.size;
         }

         private void checkForComodification() {
             if (ArrayList.this.modCount != this.modCount)
                 throw new ConcurrentModificationException();
         }

         public Spliterator<E> spliterator() {
             checkForComodification();
             return new ArrayListSpliterator<E>(ArrayList.this, offset,
                                                offset + this.size, this.modCount);
         }
     }

void sort(Comparator<? super E> c)：比较

   @Override
     @SuppressWarnings("unchecked")
     //使用自定义比较器进行排序
     public void sort(Comparator<? super E> c) {
         final int expectedModCount = modCount;
         Arrays.sort((E[]) elementData, 0, size, c);
         if (modCount != expectedModCount) {
             throw new ConcurrentModificationException();
         }
         modCount++;
     }

demo：

     public static void main(String[] args) {
         ArrayList<Integer> list = new ArrayList<>();
         list.add(1);
         list.add(3);
         list.add(7);
         list.add(0);

         Comparator c = new Comparator<Integer>() {
             @Override
             public int compare(Integer o1, Integer o2) {
                 // TODO Auto-generated method stub
                 if((int)o1<(int)o2)
                     return 1;
                     //注意！！返回值必须是一对相反数，否则无效。jdk1.7以后就是这样。
                     //        else return 0; //无效
                 else return -1;
             }
         };
         System.out.println("原始："+list);
         list.sort(c);
         System.out.println("排序后："+list);
     }

结果：

 原始：[1, 3, 7, 0]
 排序后：[7, 3, 1, 0]

void forEach(Consumer<? super E> action) ：

    @Override
     public void forEach(Consumer<? super E> 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();
         }
     }

demo：

 public static void main(String[] args) {
         ArrayList<Integer> list = new ArrayList<>();
         list.add(1);
         list.add(3);
         list.add(7);
         list.add(0);
         list.forEach(new Consumer<Integer>() {

                  @Override
                  public void accept(Integer str) {
                      if (str > 3)
                          System.out.println(str);
                  }
              }
         );
         System.out.println(list);
     }

结果：

7
[1, 3, 7, 0]

也可以写成lamb表达式，这样更简洁，

  public static void main(String[] args) {
         ArrayList<Integer> list = new ArrayList<>();
         list.add(1);
         list.add(3);
         list.add(7);
         list.add(0);
         list.forEach(str -> {
                 if (str > 3)
                     System.out.println(str);
             }
         );
         System.out.println(list);
     }

同理  void replaceAll(UnaryOperator<E> operator)，boolean removeIf(Predicate<? super E> filter) 引用博文：https://www.cnblogs.com/CarpenterLee/p/6507161.html

  @Override
     @SuppressWarnings("unchecked")
     public void replaceAll(UnaryOperator<E> 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++;
     }