顺序存储线性表_ArrayList

　　相信大家在日常开发过程中 List 应该使用的非常非常多，今天就来简单学习一下 List 的数据结构 顺序存储线性表。

一、什么是顺序存储线性表

　　顺序存储线性表是最基本、最简单、也是最常用的一种数据结构。

　　线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。

　　顺序存储线性表的相邻元素之间存在着序偶关系。如用（a1，…，ai-1，ai，ai+1，…，an）表示一个顺序表，则表中 ai-1 领先于 ai，ai 领先于 ai+1，称 ai-1 是 ai 的直接前驱元素，ai+1 是 ai 的直接后继元素。当 i=1,2，…，n-1 时，ai 有且仅有一个直接后继，当 i=2，3，…，n 时，ai 有且仅有一个直接前驱，n 为线性表的长度，如果 n==0 时，线性表为空表。

二、顺序存储线性表的特征

　　绝大多数的顺序存储线性表都有一下几个特征：

　　①. 线性表中都会存在唯一的一个 "首元素"。

　　②. 线性表中都会存在唯一的一个"尾元素"。

　　③. 线性表除最后一个元素外都存在"后继"。

　　④. 线性表除第一个元素外都存在"前驱"。

　　⑤. 存储位置连续，可以很方便的计算出各个元素的地址。

　　如果每个元素占用的存储单元为 C ，那么：

　　　　Loc（An） = Loc（An-1） + C

　　　　Loc（An） = Loc（A1） + （n - 1）* C

三、JDK源码解读

　　在 java 中，ArrayList 是典型的顺序存储线性表，下面来解读一下JDK 1.8 中 ArrayList 源码中的方法，以及父类，接口中的一些方法。

　　首先，进入到 ArrayList 中，简单看了一下ArrayList 的继承关系，ArrayList 继承 AbstractList， AbstractList 继承 AbstractCollection 类，实现了 List 接口， AbstractCollection 类实现了 Collection 接口，而 List 继承了 Collection 接口， Collection  继承了 Iterable 接口，下面就依次来简单解读这些接口以及类的实现方法以及作用。

　　ArrayList 与它的父类接口的关系图：

　　①. Iterable 接口

　　　　用途：Iterable 接口是 java 中的顶级接口之一，它的作用主要可以使实现类集合使用迭代器去遍历自己的元素。

　　　　方法：

方法名	参数	返回值	描述
Iterator	无	Iterator<T>	返回一个内部元素为 T 的迭代器
forEach	Consumer接口	void	Iterable 接口中的默认方法，其中可以传入一个Consumer的接口，可以去遍历内部的每一个元素，并且可以自定义方法，对每一个元素进行操作
spliterator	无	Spliterator<T>	Iterable 接口中的默认方法，创建并返回一个分割迭代器

 public interface Iterable<T> {
     /**
      * 获取一个内部为 T 的迭代器
      *
      * @return 返回一个迭代器.
      */
     Iterator<T> iterator();

     /**
      * 被 default 关键字修饰，表示该方法为本接口的默认方法，迭代一个
      * 集合并传入一个方法实现来对集合的每一个元素进行操作。
      */
     default void forEach(Consumer<? super T> action) {
         Objects.requireNonNull(action);// 判空操作，如果 action 为 null 则返回，NullPointerExcation()；
         for (T t : this) {
             action.accept(t);
         }
     }

     /**
      * 此方法也是该接口的默认方法，获取一个可分割迭代器。
      */
     default Spliterator<T> spliterator() {
         return Spliterators.spliteratorUnknownSize(iterator(), );
     }
 }

　　②. Collection 接口

　　　　用途：Collection接口是高度抽象出来的集合类接口，其中包含了大多数集合所需要的共同的方法，如增、删、改、查等。

　　　　方法：

方法名	参数	返回值	描述
size	无	int	获取一个集合的元素个数
isEmpty	无	boolean	判断该集合是否为空集合
contains	Object o	boolean	判断该集合是否包含 o 元素
iterator	无	Iterator<E>	返回一个内部元素为 E 的迭代器
toArray	无	Object[]	将该集合转换为数组
toArray	T[] a	T[]	将集合中的元素转换到指定的数组中，如果指定数组为空，则将集合中的元素放入一个全新的数组中，如果不为空则返回传入的数组，并且传入数组的长度为集合元素的个数
add	E e	boolean	将元素e加入到集合中
remove	Object o	boolean	将 o 元素从集合中移除
containsAll	Collection<?> c	boolean	判断集合 c 是否被该集合包含
addAll	Collection<? extends E> c	boolean	将集合 c 中的元素都添加到该集合中
removeAll	Collection<? extends E> c	boolean	将该集合中所有 c 集合中出现的元素移除
removeIf	Predicate<? super E> filter	boolean	Collection 接口中的默认方法，可以按照一定的规则去删除集合中的元素
retainAll	Collection<?> c	boolean	保留该集合中在 c 集合中存在的元素，其他元素进行移除
clear	无	void	清空集合
equals	Object o	boolean	用 o 与该集合进行比较
hashCode	无	int	获取该集合的hashCode值
spliterator	无	Spliterator<T>	Collection 接口中的默认方法，创建并返回一个分割迭代器
stream	无	Stream<E>	Collection 接口中的默认方法，将该集合转换成Stream串行流
parallelStream	无	Stream<E>	Collection 接口中的默认方法，将该集合转换成Stream并行流

 public interface Collection<E> extends Iterable<E> {
     // Query Operations

     /**
      * 获取一个集合的元素个数
      */
     int size();

     /**
      * 判断该集合是否为空集合
      */
     boolean isEmpty();

     /**
      * 判断该集合是否包含 o 元素
      */
     boolean contains(Object o);

     /**
      * 返回一个内部元素为 E 的迭代器
      */
     Iterator<E> iterator();

     /**
      * 将该集合转换为数组
      */
     Object[] toArray();

     /**
      *  将集合中的元素转换到指定的数组中，如果指定数组为空，则将集合中的元素放入一个全新的数组中，如果不为空则返回传入的数组，并且传入数组的长度为集合元素的个数
      */
     <T> T[] toArray(T[] a);

     /**
      * 将元素e加入到集合中
      */
     boolean add(E e);

     /**
      * 将 o 元素从集合中移除
      */
     boolean remove(Object o);

     /**
      * 判断集合 c 是否被该集合包含
      */
     boolean containsAll(Collection<?> c);

     /**
      * 将集合 c 中的元素都添加到该集合中
      */
     boolean addAll(Collection<? extends E> c);

     /**
      * 将该集合中所有 c 集合中出现的元素移除
      */
     boolean removeAll(Collection<?> c);

     /**
      * Collection 接口中的默认方法，可以按照一定的规则去删除集合中的元素
      */
     default boolean removeIf(Predicate<? super E> filter) {
         Objects.requireNonNull(filter);
         boolean removed = false;
         final Iterator<E> each = iterator();
         while (each.hasNext()) {
             if (filter.test(each.next())) {
                 each.remove();
                 removed = true;
             }
         }
         return removed;
     }

     /**
      * 保留该集合中在 c 集合中存在的元素，其他元素进行移除
      */
     boolean retainAll(Collection<?> c);

     /**
      * 清空集合
      */
     void clear();

     /**
      * 用 o 与该集合进行比较
      */
     boolean equals(Object o);

     /**
      * 获取该集合的hashCode值
      */
     int hashCode();

     /**
      * Collection 接口中的默认方法，创建并返回一个分割迭代器
      */
     @Override
     default Spliterator<E> spliterator() {
         return Spliterators.spliterator(this, 0);
     }

     /**
      * Collection 接口中的默认方法，将该集合转换成Stream串行流
      */
     default Stream<E> stream() {
         return StreamSupport.stream(spliterator(), false);
     }

     /**
      * Collection 接口中的默认方法，将该集合转换成Stream并行流
      */
     default Stream<E> parallelStream() {
         return StreamSupport.stream(spliterator(), true);
     }
 }

　　③. List 接口

　　　　用途：List 接口是 Conllection 接口的子接口，它可以定义一个可重复的线性集合，可以在不同的位置存放相同的元素。

　　　　方法 ：其中有许多方法与 Conllection接口的方法相同，就不在此一一列出

方法名	参数	返回值	描述
addAll	int index, Collection<? extends E> c	boolean	在指定位置index处添加集合元素c
replaceAll	UnaryOperator<E> operator	void	List 集合中的默认方法，对集合中的元素进行操作，将执行结果存入元素的位置
sort	Comparator<? super E> c	void	按照给定的排序规则进行排序
get	int index	E	返回列表中index位置的元素。
set	int index, E element	E	将列表中 index 位置的元素替换为 element
add	int index, E element	void	在列表 index 位置添加元素 element
remove	int index	E	删除 index 位置的元素
indexOf	Object o	int	返回 o 元素第一次出现的位置
lastIndexOf	Object o	int	返回 o 元素最后一次出现的位置
listIterator	无	ListIterator<E>	返回一个 ListIterator 迭代器
subList	int fromIndex, int toIndex	List<E>	返回集合从 fromIndex 的位置到 toIndex 位置的元素的集合

 public interface List<E> extends Collection<E> {

     /**
      * 在指定位置index处添加集合元素c
      */
     boolean addAll(int index, Collection<? extends E> c);

     /**
      * 对集合中的元素进行操作，将执行结果存入元素的位置
      */
     default void replaceAll(UnaryOperator<E> operator) {
         Objects.requireNonNull(operator);
         final ListIterator<E> li = this.listIterator();
         while (li.hasNext()) {
             li.set(operator.apply(li.next()));
         }
     }

     /**
      * 按照给定的排序规则进行排序
      */
     @SuppressWarnings({"unchecked", "rawtypes"})
     default void sort(Comparator<? super E> c) {
         Object[] a = this.toArray(); //首先将集合转为数组
         Arrays.sort(a, (Comparator) c); //使用数组排序的sort方法进行排序
         ListIterator<E> i = this.listIterator();
         for (Object e : a) { //再将该集合的每个位置进行替换
             i.next();
             i.set((E) e);
         }
     }

     /**
      * 返回列表中 index 位置的元素。
      */
     E get(int index);

     /**
      * 将列表中 index 位置的元素替换为 element
      */
     E set(int index, E element);

     /**
      * 在列表 index 位置添加元素 element
      */
     void add(int index, E element);

     /**
      * 删除 index 位置的元素
      */
     E remove(int index);

     /**
      * 返回 o 元素第一次出现的位置
      */
     int indexOf(Object o);

     /**
      * 返回 o 元素最后一次出现的位置
      */
     int lastIndexOf(Object o);

     /**
      * 返回一个 ListIterator 迭代器
      */
     ListIterator<E> listIterator();

     /**
      * 返回一个 从 index 开始的 ListIterator 迭代器
      */
     ListIterator<E> listIterator(int index);

     // View

     /**
      * 返回集合从 fromIndex 的位置到 toIndex 位置的元素的集合
      */
     List<E> subList(int fromIndex, int toIndex);

 }

　　④. AbstractCollection 抽象类

　　　　用途：这个类是个抽象类，直接实现了Collection接口的方法，其中为 list 和  set 直接或者间接提供了方法实现。

　　　　方法：

方法名	参数	返回值	描述
size	无	int	抽象方法，由子类实现
iterator	无	Iterator<E>	上层的获取迭代器的方法，在这里没有实现，由子类实现
isEmpty	无	boolean	判断集合是否为空
contains	Object o	boolean	判断 o 对象是否被该集合包含
toArray	无	Object[]	将集合转换为数组
toArray	T[] a	T[]	将集合转换到传入的数组中
add	E e	boolean	此类中的add方法，子类必须重写自己的方法，此类不支持单个添加元素
remove	Object o	boolean	删除 o 元素
containsAll	Collection<?> c	boolean	判断 c 集合中的元素是否都被该集合包含
addAll	Collection<? extends E> c	boolean	新增所有元素
removeAll	Collection<?> c	boolean	删除传入集合的每一个元素
retainAll	Collection<?> c	boolean	删除除传入集合元素以外的元素
clear	无	void	清空集合

 public abstract class MyAbstractCollection<E> implements Collection<E>{

     //指定集合的最大长度为 Integer.MAX_VALUE - 8
     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

     /**
      * 无参构造器
      */
     public MyAbstractCollection() {}

     /**
      * 上层的size方法，在这里没有实现。
      */
     @Override
     public abstract int size();

     /**
      * 上层的获取迭代器的方法，在这里没有实现
      */
     @Override
     public abstract Iterator<E> iterator();

     /**
      * 判断集合是否为空
      */
     @Override
     public boolean isEmpty() {
         return size() == 0;
     }

     /**
      * 判断 o 对象是否被该集合包含
      */
     @Override
     public boolean contains(Object o) {
         Iterator<E> it = iterator(); //获取迭代器
         if (o == null) { //如果 o == null 判断集合中是否有 null 元素
             while (it.hasNext()) {
                 if (it.next() == null) {
                     return true;
                 }
             }
         } else {
             while (it.hasNext()) {
                 if (it.next().equals(o)) {
                     return true;
                 }
             }
         }
         return false;
     }

     /**
      * 将集合转换为数组
      */
     @Override
     public Object[] toArray() {
         Object [] r = new Object[size()];
         Iterator<E> it = iterator();
         for (int i = 0; i < r.length; i++) {
             //如果发现迭代器中的值小于 r的长度 则进行缩容
             if (!it.hasNext()) {
                 return Arrays.copyOf(r, i);
             }
             r[i] = it.next();
         }
         //如果发现迭代器中的值大于 r的长度  则进行扩容
         return it.hasNext() ? finishToArray(r, it) : r;
     }

     /**
      * 数组扩容
      * @param r
      * @param it
      * @return
      */
     private static <T> T[] finishToArray(T[] r, Iterator<?> it) {
         int i = r.length;
         while(it.hasNext()) {
             int newLeng = r.length;
             //当新长度与原长度相同时进行扩容
             if (i == newLeng) {
                 //扩容原长度的一半+1
                 int cap = newLeng + (newLeng >> 1) + 1;
                 //此处要判断cap的值是否大于Integer的最大值
                 if (cap - MAX_ARRAY_SIZE > 0) {
                     cap = hugeCapacity(cap + 1);
                 }
                 r = Arrays.copyOf(r, cap);
             }
             r[i ++] = (T) it.next();
         }
         //最后判断r的实际长度与 i 是否相等， 如果不等就将后面多余的位置删除
         return (r.length == i) ? r : Arrays.copyOf(r, i);
     }

     /**
      * 如果数组长度超出最大长度的处理
      * @param minCapacity
      * @return
      */
     private static int hugeCapacity(int minCapacity) {
         if (minCapacity < 0) {
             throw new OutOfMemoryError("数组长度过长");
         }
         return minCapacity > MAX_ARRAY_SIZE ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
     }

     /**
      * 将集合转换到传入的数组中
      */
     @Override
     @SuppressWarnings("unchecked")
     public <T> T[] toArray(T[] a) {
         int size = size();
         //如果 a的长度大于或者等于 集合的长度则 r就等于a数组，否则就新建一个数组
         T[] r = a.length >= size() ? a : (T[]) Array.newInstance(
                 a.getClass().getComponentType(), size);
         Iterator<E> it = iterator();

         for (int i = 0; i < r.length; i++) {
             if (!it.hasNext()) {
                 if (a == r) {//如果是r与传入的数组是同一个数组 则将后面的位置 置为 null
                     r[i] = null;
                 } else if (a.length < i) { //如果传入的数组长度小于r的长度 则缩容到i的长度
                     return Arrays.copyOf(r, i);
                 } else {//如果传入的数组长度大于或等于r的长度  则将后面的位置都置为null
                     System.arraycopy(r, 0, a, 0, i);
                     if (a.length > i) {
                         a[i] = null;
                     }
                 }
                 return a;
             }
             r[i] = (T) it.next();
         }
         return it.hasNext() ? finishToArray(r, it) : r;
     }

     /**
      * 此类中的add方法，子类必须重写自己的方法，此类不支持单个添加元素
      */
     @Override
     public boolean add(E e) {
         throw new UnsupportedOperationException();
     }

     /**
      * 删除 o 元素
      */
     @Override
     public boolean remove(Object o) {
         Iterator<E> it = iterator();
         if (o == null) {
             while (it.hasNext()) { //如果 o 为 null 则将第一个 null元素删除
                 if (it.next() == null) {
                     it.remove();
                     return false;
                 }
             }
         } else {
             while (it.hasNext()) { //如果 找到第一个 与o元素相同的值 删除
                 if (o.equals(it.next())) {
                     it.remove();
                     return false;
                 }
             }
         }
         return false;
     }

     /**
      * 判断 c 集合中的元素是否都被该集合包含
      */
     @Override
     public boolean containsAll(Collection<?> c) {
         //判断 c 中每一个元素是否存在
         for (Object o : c) {
             if (!contains(o)) {
                 return false;
             }
         }
         return true;
     }

     /**
      * 新增所有元素
      */
     @Override
     public boolean addAll(Collection<? extends E> c) {
         boolean token = false;
         for (E o : c) {
             if (add(o)) {
                 token = true;
             }
         }
         return token;
     }

     /**
      * 删除传入集合的每一个元素
      */
     @Override
     public boolean removeAll(Collection<?> c) {
         Objects.requireNonNull(c);
         boolean token = false;
         Iterator<E> it = iterator();
         //迭代集合本身，判断每一个元素是否存在于集合 c 中，如果存在则删除
         while (it.hasNext()) {
             if (c.contains(it.next())) {
                 it.remove();
                 token = true;
             }
         }
         return token;
     }

     /**
      * 删除除传入集合元素以外的元素
      */
     @Override
     public boolean retainAll(Collection<?> c) {
         Objects.requireNonNull(c);
         boolean token = false;
         Iterator<E> it = iterator();
         //迭代集合本身，判断每一个元素是否存在于集合 c 中，如果不存在则删除
         while (it.hasNext()) {
             if (!c.contains(it.next())) {
                 it.remove();
                 token = true;
             }
         }
         return token;
     }

     /**
      * 清空集合
      */
     @Override
     public void clear() {
         Iterator<E> it = iterator();
         //迭代集合删除每一个元素
         while (it.hasNext()) {
             it.next();
             it.remove();
         }
     }

 }

　　⑤. AbstractList 抽象类

　　　　作用：此类继承 AbstractCollection 抽象类，继承 List 接口 ，为 ArrayList 的父类，提供了大部分集合操作的方法。此类中还存在几个内部类 分别是 ListItr，Itr，除了这两个内部类之外，SubList和RandomAccessSubList 这两个类也在 AbstractCollection 中。 ListItr 类 为list定义独有的迭代器，而 Itr 则为 ListItr 的父类。在ListItr 类中主要的一些方法都是去判断指针的位置，去描述指针是如何去移动，如何去删除元素，删除元素后对集合的改变，以及多个迭代器之间的互相的影响。SubList 类为集合提供了截取集合中某一段的方法，但是这个方法存在一些问题，他内部的方法是直接在传入集合上直接进行操作的，也就是说不仅仅会改变截取的部分集合，还会改变传入的集合，所以要谨慎使用。在下面方法中，内部类的方法就不提供了，但是会在后面的代码展示中简单解析一下代码的含义，以及操作的意义。

　　　　方法：

方法名	参数	返回值	描述
add	E e	boolean	重新父类的add方法，返回boolean值
add	int index, E element	void	实现 List 接口中的add方法，如果直接调用这个方法会抛出异常 所以在子类中一定要重写此方法
get	int index	E	List 接口中的get方法，在这里不做实现，由子类去实现
set	int index, E element	E	List 接口中的set方法，在这里只是抛出异常，子类如果直接调用，则会抛出异常， 如果要使用则需要子类去重写这个set方法
remove	int index	E	List 接口中的remove方法，在这里只是抛出异常，子类如果直接调用，则会抛出异常， 如果要使用则需要子类去重写这个remove方法
addAll	int index, Collection<? extends E> c	boolean	重写 List 接口中的addAll方法
indexOf	Object o	int	List 接口中的方法， 获取第一个与 o 对象，相同的元素的位置,如果没有则返回 -1
lastIndexOf	Object o	int	List 接口中的方法， 获取最后一个与 o 对象，相同的元素的位置
iterator	无	Iterator<E>	获取迭代器
listIterator	无	ListIterator<E>	获取ListIterator迭代器
listIterator	int index	ListIterator<E>	获取迭代器从index开始
removeRange	int fromIndex, int toIndex	void	删除集合fromIndex到toIndex的元素

 public abstract class MyAbstractList<E> extends MyAbstractCollection<E> implements List<E>{

     /**
      * 构造函数由子类调用
      */
     protected MyAbstractList() {
     }

     /**
      * 重新父类的add方法，返回boolean值
      */
     @Override
     public boolean add(E e) {
         add(size(), e);
         return true;
     }

     /**
      * 实现 List 接口中的add方法，如果直接调用这个方法会抛出异常
      * 所以在子类中一定要重写此方法
      */
     @Override
     public void add(int index, E element) {
         throw new UnsupportedOperationException();
     }

     /**
      * List 接口中的get方法，在这里不做实现，由子类去实现
      */
     @Override
     public abstract E get(int index);

     /**
      * List 接口中的set方法，在这里只是抛出异常，子类如果直接调用，则会抛出异常，
      * 如果要使用则需要子类去重写这个set方法
      */
     @Override
     public E set(int index, E element) {
         throw new UnsupportedOperationException();
     }

     /**
      * List 接口中的remove方法，在这里只是抛出异常，子类如果直接调用，则会抛出异常，
      * 如果要使用则需要子类去重写这个remove方法
      */
     @Override
     public E remove(int index) {
         throw new UnsupportedOperationException();
     }

     /**
      * 此参数为修改的次数,他主要是和迭代器一起使用，来确保线程安全，
      * 保证线程之间的修改可见性。如果出现线程不安全的情况导致这个值与迭代器中的modCount值不同时则会抛出异常。
      * 在一个迭代器初始的时候会赋予它调用这个迭代器的对象的mCount，如何在迭代器遍历的过程中，
      * 一旦发现这个对象的mcount和迭代器中存储的mcount不一样那就抛异常
      */
     protected transient int modCount = 0;

     /**
      * 重写 List 接口中的addAll方法
      */
     @Override
     public boolean addAll(int index, Collection<? extends E> c) {
         //判断数组是否越界，如果越界抛出下标越界异常
         rangeCheckForAdd(index);
         boolean token = false;
         for (E e : c) {
             add(index++, e);
             token = true;
         }
         return token;
     }

     /**
      * 判断传入的index是否在小于0 或者大于集合长度
      * @param index
      */
     private void rangeCheckForAdd(int index) {
         if (index < 0 || index > size())
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     /**
      * 获取下标的位置，和实际集合长度
      * @param index
      * @return
      */
     private String outOfBoundsMsg(int index) {
         return "Index: "+index+", Size: "+size();
     }

     /**
      * List 接口中的方法， 获取第一个与 o 对象，相同的元素的位置,如果没有则返回 -1
      */
     @Override
     public int indexOf(Object o) {
         ListIterator<E> it = listIterator();
         if (o == null) {
             while(it.hasNext()) {
                 if (it.next() == null) {
                     //获取目前迭代器的位置
                     return it.previousIndex();
                 }
             }
         } else {
             while(it.hasNext()) {
                 if (it.next().equals(o)) {
                     //获取目前迭代器上一个元素的位置
                     return it.previousIndex();
                 }
             }
         }
         return -1;
     }

     /**
      * List 接口中的方法， 获取最后一个与 o 对象，相同的元素的位置
      */
     @Override
     public int lastIndexOf(Object o) {
         ListIterator<E> it = listIterator(size());
         if (o == null) {
             //获取迭代器是否存在的上一个元素，如果存在返回true
             while (it.hasPrevious()) {
                 //获取迭代器上一个元素，反向迭代
                 if (it.previous() == null) {
                     //返回迭代器下一个元素的位置
                     return it.nextIndex();
                 }
             }
         } else {
             while (it.hasPrevious()) {
                 //获取迭代器上一个元素，反向迭代
                 if (o.equals(it.previous())) {
                     //返回迭代器下一个元素的位置
                     return it.nextIndex();
                 }
             }
         }
         return -1;
     }

     /**
      * 获取迭代器
      */
     @Override
     public Iterator<E> iterator() {
         return new Itr();
     }

     /**
      * 获取ListIterator迭代器
      */
     @Override
     public ListIterator<E> listIterator() {
         return listIterator(0);
     }

     /**
      * 获取迭代器从index开始
      */
     @Override
     public ListIterator<E> listIterator(int index) {
         rangeCheckForAdd(index);
         return new ListItr(index);
     }

     /**
      * 删除集合fromIndex到toIndex的元素
      * @param fromIndex
      * @param toIndex
      */
     protected void removeRange(int fromIndex, int toIndex) {
        ListIterator<E> it = listIterator(fromIndex);
        for (int i = 0; i < toIndex - fromIndex; i++) {
            it.next();
            it.remove();
        }
     }

     private class Itr implements Iterator<E> {

         /**
          * 调用迭代器 next 方法返回的索引
          */
         int cursor = 0;

         /**
          * 上一次调用next 方法返回的索引
          */
         int lastRet = -1;

         /**
          * 此参数为迭代器中的结构修改的次数，初始化时会将集合中的 modCount 赋值给迭代器
          */
         int expectedModCount = modCount;

         /**
          * 判断是否存在下一个元素
          */
         @Override
         public boolean hasNext() {
             return cursor != size();
         }

         @Override
         public E next() {
             //确保其他线程没有操作此集合
             checkForComodification();
             try {
                 //获取下一次next的元素的下标
                 int i = cursor;
                 //获取该下标的元素
                 E e = get(i);
                 //将此下标赋值给lastRet
                 lastRet = cursor;
                 //获取下一次next的元素下标
                 cursor ++;
                 return e;
             } catch (Exception e) {
                 checkForComodification();
                 throw new NoSuchElementException();
             }
         }

         /**
          * 此处还重写了Iterator接口的remove方法
          */
         @Override
         public void remove() {
             //如果lastRet的值小于0则说明迭代器指针还处于集合最前面，则没有删除的元素，所以抛出异常
             if(lastRet < 0) {
                 throw new IllegalStateException();
             }
             //确保其他线程没有操作此集合
             checkForComodification();
             try {
                 //删除上一个元素
                 MyAbstractList.this.remove(lastRet);
                 if (lastRet < cursor) {
                     cursor --;
                 }
                 //删除只会删除next跳过的那个元素，删除一次之后将上一个下标置为-1，保证不能多次删除
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (Exception e) {
                 throw new ConcurrentModificationException();
             }
         }

         /**
          * 使用此方法去保证线程之间的操作可见性，如果迭代器的操作次数与集合的操作次数不一致，则会抛出异常
          */
         final void checkForComodification() {
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
         }
     }

     private class ListItr extends Itr implements ListIterator<E> {

         ListItr(int index) {
             cursor = index;
         }

         /**
          * 判断上一个元素是否存在
          */
         @Override
         public boolean hasPrevious() {
             //如果cursor为0则表示指针在集合头部，则上一个元素不存在
             return cursor != 0;
         }

         /**
          * 获取上一个元素
          */
         @Override
         public E previous() {
             //判断是否被其他线程修改集合结构
             checkForComodification();
             try {
                 //获取上一个元素的下标
                 int i = cursor - 1;
                 //获取上一个元素
                 E e = get(i);
                 cursor = i;
                 lastRet = i;
                 return e;
             } catch (Exception e) {
                 checkForComodification();
                 throw new NoSuchElementException();
             }
         }

         /**
          * 获取下一个元素的下标
          */
         @Override
         public int nextIndex() {
             return cursor;
         }

         /**
          * 获取上一个元素的下标
          */
         @Override
         public int previousIndex() {
             return cursor - 1;
         }

         /**
          * 修改元素
          */
         @Override
         public void set(E e) {
             //修改元素修改的为上一次跳过的元素，如果上一次的元素是-1则说明还在集合头部，
             //无元素可以修改，所以抛出异常
             if (lastRet < 0) {
                 throw new IllegalStateException();
             }
             checkForComodification();
             try {
                 //使用MyAbstractList类的set方法
                 MyAbstractList.this.set(lastRet, e);
                 //将修改的次数赋值给迭代器
                 expectedModCount = modCount;
             } catch (Exception e2) {
                 throw new ConcurrentModificationException();
             }
         }

         /**
          * 新增元素
          */
         @Override
         public void add(E e) {
             checkForComodification();
             try {
                 //获取集合下一个元素的位置
                 int i = cursor;
                 //将元素新增到下一个位置
                 MyAbstractList.this.add(i, e);
                 lastRet = -1;
                 cursor++;
                 expectedModCount = modCount;
             } catch (Exception e2) {
                 throw new ConcurrentModificationException();
             }
         }

     }
 }

 class SubList<E> extends MyAbstractList<E> {

     //原始的集合
     private final MyAbstractList<E> l;
     //开始截取集合的起始位置
     private final int offset;
     //截取集合的长度
     private int size;

     SubList(MyAbstractList<E> list, int fromIndex, int toIndex){
         //如果起始位置小于0 则抛出异常
         if (fromIndex < 0) {
             throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
         }
         //如果结束位置大于数组长度 则抛出异常
         if (toIndex > list.size()) {
             throw new IndexOutOfBoundsException("toIndex = " + toIndex);
         }
         //如果起始位置大于结束位置 则抛出异常
         if (fromIndex > toIndex) {
             throw new IllegalArgumentException("fromIndex(" + fromIndex +
                     ") > toIndex(" + toIndex + ")");
         }
         l = list;
         offset = fromIndex;
         size = toIndex - fromIndex;
         this.modCount = l.modCount;
     }

     /**
      * 获取index的元素
      */
     @Override
     public E get(int index) {
         //判断集合下标是否不在集合范围内
         rangeCheck(index);
         checkForComodification();
         //这里为什么要加offset呢，因为此处的l为原始的list
         //而offset 为截取后的开始位置，然后加上现在要获取的元素的下标位置，
         //才是现在要获取的元素
         return l.get(index + offset);
     }

     /**
      * 修改index位置的元素
      */
     @Override
     public E set(int index, E element) {
         rangeCheck(index);
         checkForComodification();
         return l.set(index+offset, element);
     }

     /**
      * 判断集合结构是否被其他线程改变
      */
     private void checkForComodification() {
         if (this.modCount != l.modCount)
             throw new ConcurrentModificationException();
     }

     /**
      * 判断集合下标是否不在集合范围内
      * @param index
      */
     private void rangeCheck(int index) {
         if (index < 0 || index >= size)
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     /**
      * 输出集合下标和长度
      * @param index
      * @return
      */
     private String outOfBoundsMsg(int index) {
         return "Index: " + index + ", Size: " + size;
     }

     /**
      * 获取截取后集合的长度
      */
     @Override
     public int size() {
         checkForComodification();
         return size;
     }

     /**
      * 在指定位置添加元素
      */
     @Override
     public void add(int index, E element) {
         rangeCheck(index);
         checkForComodification();
         l.add(index + offset, element);
         this.modCount = l.modCount;
         size++;
     }

     /**
      * 删除指定位置元素
      */
     @Override
     public E remove(int index) {
         rangeCheck(index);
         checkForComodification();
         E e = l.remove(index + offset);
         this.modCount = l.modCount;
         size--;
         return e;
     }

     /**
      * 删除指定区域的元素
      */
     @Override
     protected void removeRange(int fromIndex, int toIndex) {
         checkForComodification();
         l.removeRange(fromIndex + offset, toIndex + offset);
         this.modCount = l.modCount;
         size -= (toIndex - fromIndex);
     }

     /**
      * 添加c到集合中，从size开始
      */
     @Override
     public boolean addAll(Collection<? extends E> c) {
         return addAll(size, c);
     }

     /**
      * 添加c到集合中，从index开始
      */
     @Override
     public boolean addAll(int index, Collection<? extends E> c) {
         rangeCheck(index);
         int cSize = c.size();
         if (c.size() == 0) {
             return false;
         }
         checkForComodification();
         l.addAll(index + offset, c);
         size += cSize;
         return true;
     }

     /**
      * 获取迭代器
      */
     public Iterator<E> iterator() {
         return listIterator();
     }

     /**
      * 获取ListIterator
      */
     public ListIterator<E> listIterator(final int index) {
         checkForComodification();
         rangeCheckForAdd(index);
         return new ListIterator<E>() {

             private final ListIterator<E> i = l.listIterator(index+offset);

             public boolean hasNext() {
                 return nextIndex() < size;
             }

             public E next() {
                 if (hasNext())
                     return i.next();
                 else
                     throw new NoSuchElementException();
             }

             public boolean hasPrevious() {
                 return previousIndex() >= 0;
             }

             public E previous() {
                 if (hasPrevious())
                     return i.previous();
                 else
                     throw new NoSuchElementException();
             }

             public int nextIndex() {
                 return i.nextIndex() - offset;
             }

             public int previousIndex() {
                 return i.previousIndex() - offset;
             }

             public void remove() {
                 i.remove();
                 SubList.this.modCount = l.modCount;
                 size--;
             }

             public void set(E e) {
                 i.set(e);
             }

             public void add(E e) {
                 i.add(e);
                 SubList.this.modCount = l.modCount;
                 size++;
             }
         };
     }

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

      /**
       * 截取集合
       */
      @Override
      public List<E> subList(int fromIndex, int toIndex) {
             return new SubList<>(this, fromIndex, toIndex);
         }
 }

 class RandomAccessSubList<E> extends SubList<E> implements RandomAccess {
     RandomAccessSubList(MyAbstractList<E> list, int fromIndex, int toIndex) {
         super(list, fromIndex, toIndex);
     }

     public List<E> subList(int fromIndex, int toIndex) {
         return new RandomAccessSubList<>(this, fromIndex, toIndex);
     }
 }

　　⑥. ArrayList

　　　　作用：ArrayList，是我们在开发过程中最常使用到的线性表的结构，它的内部可以存放重复的元素，并且可以存放null元素，属于线程不安全的集合类，查询效率高。

　　　　方法：在java8中在arrayList中加入了一些方法，还加入了获取流的类，在这里我只列出A让rayList中的方法，其他一些内部类就不一一列出，但是在下面源码解读中，我会将每个方法自己的注释以注解的方式进行注释。

方法名	入参	出参	描述
trimToSize	无	void	去除集合中预留元素的位置
ensureCapacity	int minCapacity	void	数组扩容
size	无	int	获取集合长度
isEmpty	无	boolean	判断集合是否为空
contains	Object o	boolean	判断集合是否包含 o
indexOf	Object o	int	获取o第一次出现的下标
lastIndexOf	Object o	int	获取o最后一次出现在集合的位置
clone	无	Object	克隆集合
toArray	无	Object[]	将集合转数组
toArray	T[] a	T[]	将集合转为传入的数组
elementData	int index	E	获取第 index个元素
get	int index	E	获取第index个元素
rangeCheck	int index	void	判断传入的下标是否比数组长度大
outOfBoundsMsg	int index	String	获取传入的index的长度和数组长度
set	int index, E element	E	修改index元素，将新的element放入集合index的位置，并返回oldelement
add	E e	boolean	新增元素
add	int index, E element	void	在指定位置插入元素
rangeCheckForAdd	int index	void	判断index是否在集合长度范围内
remove	int index	E	删除index的元素 ，并返回
remove	Object o	boolean	删除第一个元素 o
fastRemove	int index	void	删除 index 位置的元素
clear	无	void	清空集合
addAll	Collection<? extends E> c	boolean	将c集合添加到本集合
addAll	int index, Collection<? extends E> c	boolean	在index处，添加集合c
removeRange	int fromIndex, int toIndex	void	删除fromIndex到toIndex的元素
removeAll	Collection<?> c	boolean	删除集合中包含c集合中的元素
writeObject	java.io.ObjectOutputStream s	void	用于MyArrayList序列化使用
readObject	java.io.ObjectInputStream s	void	反序列化方法
listIterator	int index	ListIterator<E>	获取从 index 开始的List迭代器
listIterator	无	ListIterator<E>	获取从 0 开始的List迭代器
iterator	无	Iterator<E>	获取迭代器
subList	int fromIndex, int toIndex	List<E>	截取集合 从fromIndex 到 toIndex
forEach	Consumer<? super E> action	void	遍历集合，其中每个元素执行action中的方法
spliterator	无	Spliterator<E>	获取Spliterator迭代器 java8提供
removeIf	Predicate<? super E> filter	boolean	如果集合中元素在一定条件内就删除，条件由开发者传入
replaceAll	UnaryOperator<E> operator	void	按照一定的规则对集合进行操作，规则由开发者传入
sort	Comparator<? super E> c	void	java8中新加入的方法，按照一定的规则进行排序

 public class MyArrayList<E> extends AbstractList<E>
 implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

     private static final long serialVersionUID = 2572016039206533046L;

     /**
      * 创建集合时的初始 长度
      */
     private static final int DEFAULT_CAPACITY = 10;

     /**
      * 当创建集合时传入的长度为0时默认使用下面的数组
      */
     private static final Object[] EMPTY_ELEMENTDATA = {};

     /**
      * 当创建集合时不传入参数时默认使用下面的数组
      */
     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

     /**
      * 集合最大长度
      */
     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

     /**
      * 这个为集合默认使用的数组，使用 transient 修饰，将并不会被序列化到指定位置
      */
     transient Object[] elementData; 

     /**
      * elementData 数组长度
      */
     private int size;

     /**
      * 记录数组结构变化次数，保证多线程对数组结构改变时线程安全
      */
     protected transient int modCount = 0;

     /**
      * 无参构造器
      */
     public MyArrayList() {
         //直接使用默认的数组
         this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
     }

     /**
      * 第一个有参构造器，传入集合长度
      * @param initialCapacity 创建集合的长度
      */
     public MyArrayList(int initialCapacity) {
         if (initialCapacity > 0) {
             //如果长度大于 0 则创建对应长度的数组，并且赋值给elementData
             this.elementData = new Object[initialCapacity];
         } else if (initialCapacity == 0) {
             //如果长度等于 0 则直接使用默认数组 EMPTY_ELEMENTDATA
             this.elementData = EMPTY_ELEMENTDATA;
         } else {
             //如果小于 0 则抛出异常
             throw new IllegalArgumentException("Illegal Capacity: "+
                     initialCapacity);
         }

     }

     /**
      * 第二个有参构造器，传入一个集合
      * @param c
      */
     public MyArrayList(Collection<? extends E> c) {
         //将 传入的集合转为数组
         elementData = c.toArray();
         //获取集合长度
         size = elementData.length;
         if (size != 0) {
             //如果传入的集合转数组之后不是Object的数组，则copy 到Object 数组中
             if (elementData.getClass() != Object[].class) {
                 elementData = Arrays.copyOf(elementData, size, Object[].class);
             }
         } else {
             //如果传入的集合长度为 0 则使用默认的数组 EMPTY_ELEMENTDATA
             elementData = EMPTY_ELEMENTDATA;
         }
     }

     /**
      * 去除集合中预留元素的位置
      */
     public void trimToSize() {
         modCount ++;
         if (size < elementData.length) {
             //如果size与数组长度不相等，则判断size是否为0 如果为0 则使用默认数组
             //如果size不为0则将elementDta中size长度之后的预留元素的位置删除
             elementData = (size == 0) ?
                     EMPTY_ELEMENTDATA :
                         Arrays.copyOf(elementData, size);
         }
     }

     /**
      * 数组扩容
      * @param minCapacity 扩容的长度
      */
     public void ensureCapacity(int minCapacity) {
         //判断elementData 是否为默认的数组，如果是最小长度为 0 否则 最小长度为默认的10
         int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
                 ? 0 : DEFAULT_CAPACITY;
         //判断扩容的长度是否比最小长度大，如果大继续扩容，否则不扩容
         if (minCapacity > minExpand) {
             ensureExplicitCapacity(minCapacity);
         }
     }

     private void ensureCapacityInternal(int minCapacity) {
         /**
          * 判断elementData 是否为默认数组，如果是则 minCapacity 与
          * 默认长度做比较，取较大的那个数扩容
          */
         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
             minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
         }
         //否则按照传入值进行扩容
         ensureExplicitCapacity(minCapacity);
     }

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

         // 传入值与现在数组长度做比较，如果传入值大于目前数组长度继续扩容
         if (minCapacity - elementData.length > 0)
             grow(minCapacity);
     }

     private void grow(int minCapacity) {
         // 获取数组原长度
         int oldCapacity = elementData.length;
         // 数组新长度为原长度+原长度的一半
         int newCapacity = oldCapacity + (oldCapacity >> 1);
         //如果新长度小于传入的minCapacity 则新长度 = minCapacity
         if (newCapacity - minCapacity < 0)
             newCapacity = minCapacity;
         //如果新长度大于集合最大长度则执行hugeCapacity 获取扩容的长度
         if (newCapacity - MAX_ARRAY_SIZE > 0)
             newCapacity = hugeCapacity(minCapacity);
         // 进行扩容
         elementData = Arrays.copyOf(elementData, newCapacity);
     }

     private static int hugeCapacity(int minCapacity) {
         if (minCapacity < 0) // overflow
             throw new OutOfMemoryError();
         //如果新长度大于集合最大长度则返回 int的最大值，否则返回集合最大值
         return (minCapacity > MAX_ARRAY_SIZE) ?
             Integer.MAX_VALUE :
             MAX_ARRAY_SIZE;
     }

     /**
      * 获取集合长度
      */
     @Override
     public int size() {
         return size;
     }

     /**
      * 判断集合是否为空
      */
     @Override
     public boolean isEmpty() {
         return size == 0;
     }

     /**
      * 判断集合是否包含 o
      */
     @Override
     public boolean contains(Object o) {
         //如果集合中可以获取到o的下标，则说明o存在于集合中
         return indexOf(o) >= 0;
     }

     /**
      * 获取o第一次出现的下标
      */
     @Override
     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最后一次出现在集合的位置
      */
     @Override
     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;
     }

     /**
      * 克隆集合
      */
     @Override
     public Object clone() {
         try {
             MyArrayList<?> v = (MyArrayList<?>) super.clone();
             //copy原集合，并将结构改变次数置为0
             v.elementData = Arrays.copyOf(elementData, size);
             v.modCount = 0;
             return v;
         } catch (CloneNotSupportedException e) {
             throw new InternalError(e);
         }
     }

     /**
      * 将集合转数组
      */
     @Override
     public Object[] toArray() {
         return Arrays.copyOf(elementData, size);
     }

     /**
      * 将集合转为传入的数组
      */
     @Override
     public <T> T[] toArray(T[] a) {
         if (a.length < size)
             // 如果传入的数组长度小于集合的长度，则需要先扩容再copy
             return (T[]) Arrays.copyOf(elementData, size, a.getClass());
         System.arraycopy(elementData, 0, a, 0, size);
         if (a.length > size)
             a[size] = null;
         return a;
     }

     /**
      * 获取第 index个元素
      * @param index
      * @return
      */
     E elementData(int index) {
         return (E) elementData[index];
     }

     /**
      * 获取第index个元素
      */
     @Override
     public E get(int index) {
         rangeCheck(index);
         return elementData(index);
     }

     /**
      * 判断传入的下标是否比数组长度大
      * @param index
      */
     private void rangeCheck(int index) {
         if (index >= size)
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     /**
      * 获取传入的index的长度和数组长度
      * @param index
      * @return
      */
     private String outOfBoundsMsg(int index) {
         return "Index: "+index+", Size: "+size;
     }

     /**
      * 修改index元素，将新的element放入集合index的位置，并返回oldelement
      */
     @Override
     public E set(int index, E element) {
         rangeCheck(index);

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

     /**
      * 新增元素
      */
     @Override
     public boolean add(E e) {
         //数组扩容，在内部会判断数组是否需要扩容，如果长度不足则扩容，否则不扩容
         ensureCapacityInternal(size + 1);
         elementData[size++] = e;
         return true;
     }

     /**
      * 在指定位置插入元素
      */
     @Override
     public void add(int index, E element) {
         //判断index是否在集合长度范围内
         rangeCheckForAdd(index);
         //判断是否需要扩容
         ensureCapacityInternal(size + 1);
         //将index以及后面的元素向后移动一位
         System.arraycopy(elementData, index, elementData, index + 1,
                          size - index);
         //简化element 放在 index的位置上
         elementData[index] = element;
         size++;
     }

     /**
      * 判断index是否在集合长度范围内
      * @param index
      */
     private void rangeCheckForAdd(int index) {
         if (index > size || index < 0)
             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
     }

     /**
      * 删除index的元素 ，并返回
      */
     @Override
     public E remove(int index) {
         rangeCheck(index);

         modCount++;
         E oldValue = elementData(index);

         //index 位置后面元素的个数
         int numMoved = size - index - 1;
         //如果index 后面存在元素，则向前移动一位
         if (numMoved > 0)
             System.arraycopy(elementData, index+1, elementData, index,
                              numMoved);
         //将最后一位置为null
         elementData[--size] = null; 

         return oldValue;
     }

     /**
      * 删除第一个元素 o
      */
     @Override
     public boolean remove(Object o) {
         if (o == null) {
             for (int index = 0; index < size; index++)
                 if (elementData[index] == null) {
                     //删除第一个 o元素
                     fastRemove(index);
                     return true;
                 }
         } else {
             for (int index = 0; index < size; index++)
                 if (o.equals(elementData[index])) {
                     fastRemove(index);
                     return true;
                 }
         }
         return false;
     }

     /**
      * 删除 index 位置的元素
      * @param index
      */
     private void fastRemove(int index) {
         modCount++;
         //index 位置后面元素的个数
         int numMoved = size - index - 1;
         //如果index 后面存在元素，则向前移动一位
         if (numMoved > 0)
             System.arraycopy(elementData, index+1, elementData, index,
                              numMoved);
         //将最后一位置为null
         elementData[--size] = null;
     }

     /**
      * 清空集合
      */
     @Override
     public void clear() {
         modCount++;

         // 将每一个元素置null
         for (int i = 0; i < size; i++)
             elementData[i] = null;

         size = 0;
     }

     /**
      * 将c集合添加到本集合
      */
     @Override
     public boolean addAll(Collection<? extends E> c) {
         //转数组
         Object[] a = c.toArray();
         int numNew = a.length;
         //扩容
         ensureCapacityInternal(size + numNew);
         //copy数组，将a数组从0开始copy到 elementData，从size开始，copy numNew个元素
         System.arraycopy(a, 0, elementData, size, numNew);
         //修改长度
         size += numNew;
         return numNew != 0;
     }

     /**
      * 在index处，添加集合c
      */
     @Override
     public boolean addAll(int index, Collection<? extends E> c) {
         //判断index是否超出集合范围
         rangeCheckForAdd(index);

         Object[] a = c.toArray();
         int numNew = a.length;
         //数组扩容
         ensureCapacityInternal(size + numNew);  

         int numMoved = size - index;
         if (numMoved > 0)
             //将index后面的元素向后移动 c 集合中元素个数个长度
             System.arraycopy(elementData, index, elementData, index + numNew,
                              numMoved);
         //将a集合中的元素从0开始复制到elementData的index位置
         System.arraycopy(a, 0, elementData, index, numNew);
         //修改长度
         size += numNew;
         return numNew != 0;
     }

     /**
      * 删除fromIndex到toIndex的元素
      */
     @Override
     protected void removeRange(int fromIndex, int toIndex) {
         modCount++;
         int numMoved = size - toIndex;
         //将elementData 从 toIndex开始的元素 移动到fromIndex的位置，移动 numMoved个元素
         System.arraycopy(elementData, toIndex, elementData, fromIndex,
                          numMoved);

         int newSize = size - (toIndex-fromIndex);
         //将后面移动的元素的位置置为null
         for (int i = newSize; i < size; i++) {
             elementData[i] = null;
         }
         size = newSize;
     }

     /**
      * 删除集合中包含c集合中的元素
      */
     @Override
     public boolean removeAll(Collection<?> c) {
         //判断c是否为null
         Objects.requireNonNull(c);
         return batchRemove(c, false);
     }

     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++)
                 //w为下一个不重复元素的下标，r为目前遍历的元素下标，将不重复的元素放到w位置
                 if (c.contains(elementData[r]) == complement)
                     elementData[w++] = elementData[r];
         } finally {
             //如果上面的循环没有结束，则将没有遍历完的元素向前移动
             if (r != size) {
                 System.arraycopy(elementData, r,
                                  elementData, w,
                                  size - r);
                 w += size - r;
             }
             //将w后面的元素全部置为null
             if (w != size) {
                 for (int i = w; i < size; i++)
                     elementData[i] = null;
                 modCount += size - w;
                 //长度修改为w
                 size = w;
                 modified = true;
             }
         }
         return modified;
     }

     /**
      * 用于MyArrayList序列化使用
      * @param s
      * @throws java.io.IOException
      */
     private void writeObject(java.io.ObjectOutputStream s)
             throws java.io.IOException{
         // 首先先将非 transient 的进行序列化
         int expectedModCount = modCount;
         s.defaultWriteObject();

         // 再将集合的长度序列化
         s.writeInt(size);

         // 最后将，集合中非 null的进行序列化。我们知道集合初始化有10个长度，也许只用用几个，
         //那么这时序列化全部的话就会把后面没有使用的地址的null也序列化进去，这里序列化时，
         //调用此方法就会只序列化有值的区域，从而增加序列化效率，剪小序列化后的文件
         for (int i=0; i<size; i++) {
             s.writeObject(elementData[i]);
         }
         //如何在序列化过程中集合结构被其他线程修改，则序列化失败
         if (modCount != expectedModCount) {
             throw new ConcurrentModificationException();
         }
     }

     /**
      * 反序列化方法
      * @param s
      * @throws java.io.IOException
      * @throws ClassNotFoundException
      */
     private void readObject(java.io.ObjectInputStream s)
             throws java.io.IOException, ClassNotFoundException {
         elementData = EMPTY_ELEMENTDATA;

         // 首先将非transient 修饰的进行反序列化
         s.defaultReadObject();
         s.readInt(); 

         if (size > 0) {
             // 数组扩容
             ensureCapacityInternal(size);

             Object[] a = elementData;
             // 解析size个 元素进行反序列化
             for (int i=0; i<size; i++) {
                 a[i] = s.readObject();
             }
         }
     }

     /**
      * 获取从 index 开始的List迭代器
      */
     public ListIterator<E> listIterator(int index) {
         if (index < 0 || index > size)
             throw new IndexOutOfBoundsException("Index: "+index);
         return new ListItr(index);
     }

     /**
      * 获取从 0 开始的List迭代器
      */
     public ListIterator<E> listIterator() {
         return new ListItr(0);
     }

     /**
      * 获取迭代器
      */
     public Iterator<E> iterator() {
         return new Itr();
     }

     private class Itr implements Iterator<E> {

         int cursor;       // 迭代器指针指向的下一个元素的下标
         int lastRet = -1; // 迭代器指针跳过的上一个元素的下标，-1表示没有
         int expectedModCount = modCount;

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

         @Override
         public E next() {
             //判断集合结构修改次数是否与迭代器修改次数相同
             checkForComodification();
             int i = cursor;
             if (i > size) {
                 throw new NoSuchElementException();
             }
             Object [] elementData = MyArrayList.this.elementData;
             if (i > elementData.length) {
                 throw new ConcurrentModificationException();
             }
             return null;
         }

         /**
          * 删除指针跳过的元素
          */
         public void remove() {
             if (lastRet < 0) {
                 throw new IllegalStateException();
             }
             checkForComodification();
             try {
                 //使用arrayList的删除方法
                 MyArrayList.this.remove(lastRet);
                 cursor = lastRet;
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException e) {
                 throw new ConcurrentModificationException();
             }
         }

         /**
          * java8新加入的方法，迭代集合，并自定义方法执行,但是这里需要注意的是，迭代的集合是从指针的下一个元素开始
          * 并不一定是从集合的开始执行，所以请谨慎使用
          */
         @SuppressWarnings("unchecked")
         public void forEachRemaining(Consumer<? super E> consumer) {
             //判断传入的方法是否为null
             Objects.requireNonNull(consumer);
             final int size = MyArrayList.this.size;
             int i = cursor;
             //指针在最后的位置
             if (i > size) {
                 return;
             }
             final Object [] elementData = MyArrayList.this.elementData;
             if (i >= elementData.length) {
                 throw new ConcurrentModificationException();
             }
             while(i != size && modCount == expectedModCount) {
                 consumer.accept((E)elementData[i++]);
             }
             cursor = i;
             lastRet = i - 1;
             checkForComodification();
         }

         /**
          * 判断集合结构修改次数是否与迭代器修改次数相同
          */
         final void checkForComodification() {
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
         }

     }

     /**
      * list 的迭代器
      *
      */
     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;
             //如果上一个元素下标小于0，说明不存在上一个元素
             if (i < 0)
                 throw new NoSuchElementException();
             Object[] elementData = MyArrayList.this.elementData;
             //如果上一个元素下标大于数组的长度，则抛出异常
             if (i >= elementData.length)
                 throw new ConcurrentModificationException();
             cursor = i;
             return (E) elementData[lastRet = i];
         }

         /**
          * 修改指针刚跳过的元素
          */
         public void set(E e) {
             //如果lastRet小于0 则说明没有跳过任何一个元素
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();

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

         /**
          * 在指针后加入元素
          */
         public void add(E e) {
             checkForComodification();
             try {
                 int i = cursor;
                 MyArrayList.this.add(i, e);
                 cursor = i + 1;
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }
     }

     /**
      * 截取集合 从fromIndex 到 toIndex
      */
     public List<E> subList(int fromIndex, int toIndex) {
         subListRangeCheck(fromIndex, toIndex, size);
         return new SubList(this, 0, fromIndex, toIndex);
     }

     /**
      * 判断截取集合的位置是否正确
      * @param fromIndex
      * @param toIndex
      * @param size
      */
     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 = MyArrayList.this.modCount;
         }

         /**
          * 修改index元素
          */
         public E set(int index, E e) {
             //判断index是否不在集合范围内
             rangeCheck(index);
             checkForComodification();
             //获取原来index位置的元素
             E oldValue = MyArrayList.this.elementData(offset + index);
             //使用e 替代原来位置的元素
             MyArrayList.this.elementData[offset + index] = e;
             return oldValue;
         }

         /**
          * index位置的元素
          */
         public E get(int index) {
             rangeCheck(index);
             checkForComodification();
             return MyArrayList.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;
         }

         /**
          * 删除从fromIndex开始到toIndex位置的元素
          */
         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);
         }

         /**
          * 在index位置后加入集合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();
         }

         /**
          * 获取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 = MyArrayList.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 = MyArrayList.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 = MyArrayList.this.elementData;
                     if (offset + i >= elementData.length)
                         throw new ConcurrentModificationException();
                     cursor = i;
                     return (E) elementData[offset + (lastRet = i)];
                 }

                 /**
                  * 循环遍历指针后面的元素，并执行consumer的方法
                  */
                 @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 = MyArrayList.this.elementData;
                     if (offset + i >= elementData.length) {
                         throw new ConcurrentModificationException();
                     }
                     while (i != size && modCount == expectedModCount) {
                         consumer.accept((E) elementData[offset + (i++)]);
                     }
                     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 = MyArrayList.this.modCount;
                     } catch (IndexOutOfBoundsException ex) {
                         throw new ConcurrentModificationException();
                     }
                 }

                 /**
                  * 修改元素
                  */
                 public void set(E e) {
                     if (lastRet < 0)
                         throw new IllegalStateException();
                     checkForComodification();

                     try {
                         MyArrayList.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 = MyArrayList.this.modCount;
                     } catch (IndexOutOfBoundsException ex) {
                         throw new ConcurrentModificationException();
                     }
                 }

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

         /**
          * 截取集合从fromIndex到toIndex
          */
         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 (MyArrayList.this.modCount != this.modCount)
                 throw new ConcurrentModificationException();
         }

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

     /**
      * 遍历集合，其中每个元素执行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();
         }
     }

     /**
      * 获取Spliterator迭代器 java8提供
      */
     @Override
     public Spliterator<E> spliterator() {
         return new ArrayListSpliterator<>(this, 0, -1, 0);
     }

     static final class ArrayListSpliterator<E> implements Spliterator<E> {

         private final MyArrayList<E> list; //集合
         private int index; //起始位置
         private int fence; //结束位置 -1表示最后
         private int expectedModCount; //结构改变次数

         ArrayListSpliterator(MyArrayList<E> list, int origin, int fence,
                              int expectedModCount) {
             this.list = list;
             this.index = origin;
             this.fence = fence;
             this.expectedModCount = expectedModCount;
         }

         /**
          * 获取结束位置
          * @return
          */
         private int getFence() {
             int hi;
             MyArrayList<E> lst;
             //如果fence = -1则说明已经到达最后位置
             if ((hi = fence) < 0) {
                 //如果集合为null则最后位置为0
                 if ((lst = list) == null)
                     hi = fence = 0;
                 else {
                     //否则返回集合长度
                     expectedModCount = lst.modCount;
                     hi = fence = lst.size;
                 }
             }
             return hi;
         }

         /**
          * 分割迭代器，每调用一次，将原来的迭代器等分为两份，并返回索引靠前的那一个子迭代器。
          */
         public ArrayListSpliterator<E> trySplit() {
             int hi = getFence(), lo = index, mid = (lo + hi) >>> 1;
             return (lo >= mid) ? null :
                 new ArrayListSpliterator<E>(list, lo, index = mid,
                                             expectedModCount);
         }

         /**
          * 获取下一个元素并执行action方法
          */
         public boolean tryAdvance(Consumer<? super E> action) {
             if (action == null)
                 throw new NullPointerException();
             int hi = getFence(), i = index;
             //如果开始位置小于结束
             if (i < hi) {
                 index = i + 1;
                 //则获取下一个元素
                 @SuppressWarnings("unchecked") E e = (E)list.elementData[i];
                 //执行action的方法
                 action.accept(e);
                 if (list.modCount != expectedModCount)
                     throw new ConcurrentModificationException();
                 return true;
             }
             return false;
         }

         /**
          * 循环执行action方法
          */
         public void forEachRemaining(Consumer<? super E> action) {
             int i, hi, mc;
             MyArrayList<E> lst; Object[] a;
             if (action == null)
                 throw new NullPointerException();
             if ((lst = list) != null && (a = lst.elementData) != null) {
                 if ((hi = fence) < 0) {
                     mc = lst.modCount;
                     hi = lst.size;
                 }
                 else
                     mc = expectedModCount;
                 if ((i = index) >= 0 && (index = hi) <= a.length) {
                     for (; i < hi; ++i) {
                         @SuppressWarnings("unchecked") E e = (E) a[i];
                         action.accept(e);
                     }
                     if (lst.modCount == mc)
                         return;
                 }
             }
             throw new ConcurrentModificationException();
         }

         public long estimateSize() {
             return (long) (getFence() - index);
         }

         public int characteristics() {
             return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;
         }
     }

     /**
      * 如果集合中元素在一定条件内就删除，条件由开发者传入
      */
     @Override
     public boolean removeIf(Predicate<? super E> filter) {
         Objects.requireNonNull(filter);
         int removeCount = 0;
         //创建一个size长度的BitSet
         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的 i 位置 设置为true
                 removeSet.set(i);
                 removeCount++;
             }
         }
         if (modCount != expectedModCount) {
             throw new ConcurrentModificationException();
         }
         //判读是否有元素需要被删除
         final boolean anyToRemove = removeCount > 0;
         if (anyToRemove) {
             //获取删除元素后 数组的长度
             final int newSize = size - removeCount;
             for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) {
                 //获取removeSet中i后面第一个为false的元素下标，
                 i = removeSet.nextClearBit(i);
                 elementData[j] = elementData[i];
             }
             //将删除结束后，新数组长度后面的元素全部置为null、
             for (int k=newSize; k < size; k++) {
                 elementData[k] = null;
             }
             this.size = newSize;
             if (modCount != expectedModCount) {
                 throw new ConcurrentModificationException();
             }
             modCount++;
         }

         return anyToRemove;
     }

     /**
      * 按照一定的规则对集合进行操作，规则由开发者传入
      */
     @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++;
     }

     /**
      * java8中新加入的方法，按照一定的规则进行排序
      */
     @Override
     @SuppressWarnings("unchecked")
     public void sort(Comparator<? super E> c) {
         final int expectedModCount = modCount;
         //调用arrays的方法传入数组，从0开始size个元素，按照c的规则进行排序
         Arrays.sort((E[]) elementData, 0, size, c);
         if (modCount != expectedModCount) {
             throw new ConcurrentModificationException();
         }
         modCount++;
     }

 }

　　以上就是我在学习线性表时的一些感悟以及对ArrayList以及相关的一些接口，父类的源码的解读，其中代码中的注释均是我自己在读源码过程中的理解。如过有地方理解的和大家理解的不一样，还请提出来一起探讨。

-------------------- END ---------------------

最后附上作者的微信公众号地址和博客地址

公众号：wuyouxin_gzh

Herrt灬凌夜：https://www.cnblogs.com/wuyx/

版权说明：欢迎以任何方式进行转载，但请在转载后注明出处！