前言

AbstractList是实现List接口的一个抽象类，它的地位之与List类似于AbstractCollection之与Collection，同事，AbstractList继承了AbstractCollection，并针对List接口给出了一些默认的实现。而且它是针对随机访问储存数据的方式的，如果需要使用顺序访问储存数据方式，还有一个AbstractSequentialList是AbstractList的子类，顺序访问时应该优先使用它。

框架图

Java基础系列（四十二）：集合之AbstractList - 图1

源码

接下来，我们来看一下AbstractList的源码，看看他针对于List接口相较于AbstractCollection给出了哪些不同的实现方法。

  3. package java.util;
  6. public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
  8.     //只提供了一个protected修饰的无参构造器，供子类使用。
  9.     protected AbstractList() {
  10.     }
  12.     //添加一个元素，实际上并没有实现。
  13.     public boolean add(E e) {
  14.         //实际上，size()在这个方法中并没有实现，交由子类去实现。
  15.         add(size(), e);
  16.         return true;
  17.     }
  19.     //抽象方法，需要子类去实现，根据索引值获取集合中的某个元素(随机访问)
  20.     abstract public E get(int index);
  22.     //由于该集合是不可变的，所以一切可能会改变集合元素的操作都会抛出一个UnsupportedOperationException()
  23.     public E set(int index, E element) {
  24.         throw new UnsupportedOperationException();
  25.     }
  27.     public void add(int index, E element) {
  28.         throw new UnsupportedOperationException();
  29.     }
  32.     public E remove(int index) {
  33.         throw new UnsupportedOperationException();
  34.     }
  37.     // Search Operations
  39.     //获取某个元素在集合中的索引
  40.     public int indexOf(Object o) {
  41.         //这里是由AbstractList内部已经提供了Iterator, ListIterator迭代器的实现类，分别为Itr，ListItr。这里是调用了一个实例化ListItr的方法
  42.         ListIterator<E> it = listIterator();
  43.         if (o==null) {
  44.             while (it.hasNext())
  45.                 if (it.next()==null)
  46.                     return it.previousIndex();
  47.         } else {
  48.             while (it.hasNext())
  49.                 if (o.equals(it.next()))
  50.                     return it.previousIndex();
  51.         }
  52.         //如果集合中不存在该元素，返回-1
  53.         return -1;
  54.     }
  56.     //获取某个元素在集合中最后一次出现的索引
  57.     public int lastIndexOf(Object o) {
  58.         ListIterator<E> it = listIterator(size());
  59.         if (o==null) {
  60.             while (it.hasPrevious())
  61.                 if (it.previous()==null)
  62.                     return it.nextIndex();
  63.         } else {
  64.             while (it.hasPrevious())
  65.                 if (o.equals(it.previous()))
  66.                     return it.nextIndex();
  67.         }
  68.         return -1;
  69.     }
  72.     // Bulk Operations
  74.     //清除集合中的元素
  75.     public void clear() {
  76.         removeRange(0, size());
  77.     }
  79.     //从某个索引开始，将c中的元素全部插入到集合中
  80.     public boolean addAll(int index, Collection<? extends E> c) {
  81.         rangeCheckForAdd(index);
  82.         boolean modified = false;
  83.         for (E e : c) {
  84.             add(index++, e);
  85.             modified = true;
  86.         }
  87.         return modified;
  88.     }
  91.     // Iterators
  93.     //获取Iterator接口Itr实现类迭代器
  94.     public Iterator<E> iterator() {
  95.         return new Itr();
  96.     }
  98.     //获取从0开始（初始位置）的ListIterator的实现类ListItr
  99.     public ListIterator<E> listIterator() {
  100.         return listIterator(0);
  101.     }
  103.     //获取从索引等于index的位置的迭代器
  104.     public ListIterator<E> listIterator(final int index) {
  105.         rangeCheckForAdd(index);
  106.         return new ListItr(index);
  107.     }
  109.     /**
  110.      *    内部实现了Iterator接口的实现类Itr
  111.      */
  112.     private class Itr implements Iterator<E> {
  114.         //光标位置
  115.         int cursor = 0;
  117.         //上一次迭代到的元素的光标位置，如果是末尾会置为-1
  118.         int lastRet = -1;
  120.         //并发标志，如果两个值不一致，说明发生了并发操作，就会报错
  121.         int expectedModCount = modCount;
  123.         //判断是否存在下一条数据，即迭代器的位置是否走到尾 
  124.         public boolean hasNext() {
  125.             //如果光标位置不等于集合个数，说明迭代器没有走到末尾，返回true
  126.             return cursor != size();
  127.         }
  129.         //获取下一个元素
  130.         public E next() {
  131.             //判断是否有并发操作
  132.             checkForComodification();
  133.             try {
  134.                 int i = cursor;
  135.                 //通过索引位置来获取元素
  136.                 E next = get(i);
  137.                 lastRet = i;
  138.                 //每次将+1，将迭代器位置向后移动一位
  139.                 cursor = i + 1;
  140.                 return next;
  141.             } catch (IndexOutOfBoundsException e) {
  142.                 //时刻检查是否有并发操作
  143.                 checkForComodification();
  144.                 throw new NoSuchElementException();
  145.             }
  146.         }
  148.         //删除上一次迭代器越过的元素
  149.         public void remove() {
  150.             if (lastRet < 0)
  151.                 throw new IllegalStateException();
  152.             checkForComodification();
  154.             try {
  155.                    //调用需要子类去实现的remove方法
  156.                 AbstractList.this.remove(lastRet);
  157.                 if (lastRet < cursor)
  158.                     cursor--;
  159.                 //每次删除后，将lastRet置为-1，防止连续的删除
  160.                 lastRet = -1;
  161.                 //将修改次数赋给迭代器对对象的结构修改次数这个会在下面进行详解
  162.                 expectedModCount = modCount;
  163.             } catch (IndexOutOfBoundsException e) {
  164.                 //如果出现索引越界，说明发生了并发的操作导致，所以抛出一个并发操作异常。
  165.                 throw new ConcurrentModificationException();
  166.             }
  167.         }
  169.         //判断是否发生了并发操作
  170.         final void checkForComodification() {
  171.             if (modCount != expectedModCount)
  172.                 throw new ConcurrentModificationException();
  173.         }
  174.     }
  176.     //继承自Itr的ListIterator的实现类ListItr
  177.     private class ListItr extends Itr implements ListIterator<E> {
  179.         //指定光标位置等于索引的迭代器构造
  180.         ListItr(int index) {
  181.             cursor = index;
  182.         }
  184.         //如果不是第一位，返回true
  185.         public boolean hasPrevious() {
  186.             return cursor != 0;
  187.         }
  189.         //获取上一位的元素，这里在后面会有画图帮助理解
  190.         public E previous() {
  191.             checkForComodification();
  192.             try {
  193.                 //这里和父类的写法略有不同，先将光标的位置进行减一
  194.                 int i = cursor - 1;
  195.                 E previous = get(i);
  196.                 //因为需要返回的是前一位的元素，所以这里的光标值和上一次迭代到的光标的位置实际上是一样的
  197.                 lastRet = cursor = i;
  198.                 return previous;
  199.             } catch (IndexOutOfBoundsException e) {
  200.                 checkForComodification();
  201.                 throw new NoSuchElementException();
  202.             }
  203.         }
  205.         //下一位的索引值等于光标值
  206.         public int nextIndex() {
  207.             return cursor;
  208.         }
  210.         //上一位的索引值等于光标值减一
  211.         public int previousIndex() {
  212.             return cursor-1;
  213.         }
  216.         //设置元素
  217.         public void set(E e) {
  218.             if (lastRet < 0)
  219.                 throw new IllegalStateException();
  220.             checkForComodification();
  222.             try {
  223.                 //默认设置的位置是上一次迭代器越过的元素
  224.                 AbstractList.this.set(lastRet, e);
  225.                 expectedModCount = modCount;
  226.             } catch (IndexOutOfBoundsException ex) {
  227.                 throw new ConcurrentModificationException();
  228.             }
  229.         }
  231.         //添加元素
  232.         public void add(E e) {
  233.             checkForComodification();
  234.             try {
  235.                 //设置添加的位置为当前光标所在的位置
  236.                 int i = cursor;
  237.                 AbstractList.this.add(i, e);
  238.                 //这里讲lastRet设置为-1，即添加的元素不允许立即删除
  239.                 lastRet = -1;
  240.                 //添加后，将光标移到
  241.                 cursor = i + 1;
  242.                 //迭代器并发标志和集合并发标志统一
  243.                 expectedModCount = modCount;
  244.             } catch (IndexOutOfBoundsException ex) {
  245.                 //如果出现了索引越界，说明发生了并发操作
  246.                 throw new ConcurrentModificationException();
  247.             }
  248.         }
  249.     }
  251.     //切取子List
  252.     public List<E> subList(int fromIndex, int toIndex) {
  253.         //是否支持随机访问
  254.         return (this instanceof RandomAccess ?
  255.                 new RandomAccessSubList<>(this, fromIndex, toIndex) :
  256.                 new SubList<>(this, fromIndex, toIndex));
  257.     }
  259.     // Comparison and hashing
  261.     //通过迭代器来遍历进行判断每项是否相等来重写equals方法
  262.     public boolean equals(Object o) {
  263.         if (o == this)
  264.             return true;
  265.         if (!(o instanceof List))
  266.             return false;
  268.         ListIterator<E> e1 = listIterator();
  269.         ListIterator<?> e2 = ((List<?>) o).listIterator();
  270.         while (e1.hasNext() && e2.hasNext()) {
  271.             E o1 = e1.next();
  272.             Object o2 = e2.next();
  273.             if (!(o1==null ? o2==null : o1.equals(o2)))
  274.                 return false;
  275.         }
  276.         return !(e1.hasNext() || e2.hasNext());
  277.     }
  279.     //重写hashCode
  280.     public int hashCode() {
  281.         int hashCode = 1;
  282.         for (E e : this)
  283.             hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
  284.         return hashCode;
  285.     }
  287.     //使用迭代器成段删除集合中的元素
  288.     protected void removeRange(int fromIndex, int toIndex) {
  289.         ListIterator<E> it = listIterator(fromIndex);
  290.         for (int i=0, n=toIndex-fromIndex; i<n; i++) {
  291.             it.next();
  292.             it.remove();
  293.         }
  294.     }
  296.     //？
  297.     protected transient int modCount = 0;
  299.     //判断索引是否越界
  300.     private void rangeCheckForAdd(int index) {
  301.         if (index < 0 || index > size())
  302.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  303.     }
  305.     private String outOfBoundsMsg(int index) {
  306.         return "Index: "+index+", Size: "+size();
  307.     }
  308. }
  310. //继承自AbstractList的内部类SubList，代表了它父类的一部分
  311. class SubList<E> extends AbstractList<E> {
  313.     private final AbstractList<E> l;
  314.     private final int offset;
  315.     private int size;
  317.     //根据父类来构造一个SubList
  318.     SubList(AbstractList<E> list, int fromIndex, int toIndex) {
  319.         if (fromIndex < 0)
  320.             throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
  321.         if (toIndex > list.size())
  322.             throw new IndexOutOfBoundsException("toIndex = " + toIndex);
  323.         if (fromIndex > toIndex)
  324.             throw new IllegalArgumentException("fromIndex(" + fromIndex +
  325.                                                ") > toIndex(" + toIndex + ")");
  326.         l = list;
  327.         offset = fromIndex;
  328.         size = toIndex - fromIndex;
  329.         //修改次数（并发标志）和父类保持一致
  330.         this.modCount = l.modCount;
  331.     }
  333.     //实际上还是调用的父类的set方法和get方法
  334.     public E set(int index, E element) {
  335.         rangeCheck(index);
  336.         checkForComodification();
  337.         return l.set(index+offset, element);
  338.     }
  340.     public E get(int index) {
  341.         rangeCheck(index);
  342.         checkForComodification();
  343.         return l.get(index+offset);
  344.     }
  346.     //size = toIndex - fromIndex;
  347.     public int size() {
  348.         checkForComodification();
  349.         return size;
  350.     }
  352.     public void add(int index, E element) {
  353.         rangeCheckForAdd(index);
  354.         checkForComodification();
  355.         //实际上还是在父类上进行添加
  356.         l.add(index+offset, element);
  357.         this.modCount = l.modCount;
  358.         //然后把size + 1
  359.         size++;
  360.     }
  362.     public E remove(int index) {
  363.         rangeCheck(index);
  364.         checkForComodification();
  365.         //实际上还是在父类上进行删除
  366.         E result = l.remove(index+offset);
  367.         this.modCount = l.modCount;
  368.         size--;
  369.         return result;
  370.     }
  372.     protected void removeRange(int fromIndex, int toIndex) {
  373.         checkForComodification();
  374.         //调用父类的removeRange方法
  375.         l.removeRange(fromIndex+offset, toIndex+offset);
  376.         this.modCount = l.modCount;
  377.         size -= (toIndex-fromIndex);
  378.     }
  380.     public boolean addAll(Collection<? extends E> c) {
  381.         return addAll(size, c);
  382.     }
  384.     public boolean addAll(int index, Collection<? extends E> c) {
  386.         rangeCheckForAdd(index);
  387.         int cSize = c.size();
  388.         if (cSize==0)
  389.             return false;
  391.         checkForComodification();
  392.         //在当前的子集合开始的位置进行插入
  393.         l.addAll(offset+index, c);
  394.         this.modCount = l.modCount;
  395.         size += cSize;
  396.         return true;
  397.     }
  399.     public Iterator<E> iterator() {
  400.         return listIterator();
  401.     }
  403.     public ListIterator<E> listIterator(final int index) {
  404.         checkForComodification();
  405.         rangeCheckForAdd(index);
  407.         //返回的是一个匿名内部类
  408.         return new ListIterator<E>() {
  409.             private final ListIterator<E> i = l.listIterator(index+offset);
  411.             public boolean hasNext() {
  412.                 return nextIndex() < size;
  413.             }
  415.             public E next() {
  416.                 if (hasNext())
  417.                     return i.next();
  418.                 else
  419.                     throw new NoSuchElementException();
  420.             }
  422.             public boolean hasPrevious() {
  423.                 return previousIndex() >= 0;
  424.             }
  426.             public E previous() {
  427.                 if (hasPrevious())
  428.                     return i.previous();
  429.                 else
  430.                     throw new NoSuchElementException();
  431.             }
  433.             public int nextIndex() {
  434.                 return i.nextIndex() - offset;
  435.             }
  437.             public int previousIndex() {
  438.                 return i.previousIndex() - offset;
  439.             }
  441.             public void remove() {
  442.                 i.remove();
  443.                 SubList.this.modCount = l.modCount;
  444.                 size--;
  445.             }
  447.             public void set(E e) {
  448.                 i.set(e);
  449.             }
  451.             public void add(E e) {
  452.                 i.add(e);
  453.                 SubList.this.modCount = l.modCount;
  454.                 size++;
  455.             }
  456.         };
  457.     }
  459.     public List<E> subList(int fromIndex, int toIndex) {
  460.         return new SubList<>(this, fromIndex, toIndex);
  461.     }
  463.     private void rangeCheck(int index) {
  464.         if (index < 0 || index >= size)
  465.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  466.     }
  468.     private void rangeCheckForAdd(int index) {
  469.         if (index < 0 || index > size)
  470.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
  471.     }
  473.     private String outOfBoundsMsg(int index) {
  474.         return "Index: "+index+", Size: "+size;
  475.     }
  477.     private void checkForComodification() {
  478.         if (this.modCount != l.modCount)
  479.             throw new ConcurrentModificationException();
  480.     }
  481. }
  483. //相较于SubList内部类，多了一个是否可以随机访问的标志
  484. class RandomAccessSubList<E> extends SubList<E> implements RandomAccess {
  485.     RandomAccessSubList(AbstractList<E> list, int fromIndex, int toIndex) {
  486.         super(list, fromIndex, toIndex);
  487.     }
  489.     public List<E> subList(int fromIndex, int toIndex) {
  490.         return new RandomAccessSubList<>(this, fromIndex, toIndex);
  491.     }
  492. }

通过源码，我们可以发现，AbstractList的源码在结构上分为了两种内部迭代器，两种内部类以及AbstractList本身的代码，接下来，我们来分别解释在阅读源码中遇到的一些问题

索引和游标的关系

Java基础系列（四十二）：集合之AbstractList - 图2这里我画了一个图，然后对照着这个图，我们再来看一下ListItr中的一些代码：

         //下一位的索引值等于光标值
        public int nextIndex() {
            return cursor;
        }

        //上一位的索引值等于光标值减一
        public int previousIndex() {
            //其实这里并不理解，为啥不去检查索引越界。。
            return cursor-1;
        }

假定迭代器现在运行到1所在的位置，可以很容易的看出当迭代器处于这个位置的时候，去调用nextIndex()方法得到的是1，而调用previousIndex得到的就是0。这是完全符合我们的逻辑的，接下来，我们再来看previous()方法的源码：

//获取上一位的元素，这里在后面会有画图帮助理解
public E previous() {
    checkForComodification();
    try {
        //这里和父类的写法略有不同，先将光标的位置进行减一
        int i = cursor - 1;
        E previous = get(i);
        //因为需要返回的是前一位的元素，所以这里的光标值和上一次迭代到的光标的位置实际上是一样的
        lastRet = cursor = i;
        return previous;
    } catch (IndexOutOfBoundsException e) {
        checkForComodification();
        throw new NoSuchElementException();
    }
}

其实这里我在分析的时候是存在疑问的（为什么这里的lastRet等于cursor，而Itr中的next()方法的实现中cursor实际上等于lastRet - 1），在画完图分析索引和游标的关系之后又来看一遍才恍然大悟，

这里的lastRet代表的是上一次迭代到的元素的光标位置，所以，我们来举个例子，当迭代器在4的位置的时候，使用了previous()方法，这时的迭代器的位置是在3，而上次迭代到的元素的游标位置也是3，而如果使用了next()方法，使用之后，迭代器的位置在5，而上一次迭代到的元素确是4。这也印证了nextIndex()和previousIndex()的逻辑。

expectedModCount 和 modCount

从源码中我们可以看到

//这个变量是transient的，也就说序列化的时候是不需要储存的 
protected transient int modCount = 0;

这个变量代表着当前集合对象的结构性修改的次数，每次进行修改都会进行加1的操作，而expectedModCount代表的是迭代器对对象进行结构性修改的次数，这样的话每次进行结构性修改的时候都会将expectedModCount和modCount进行对比，如果相等的话，说明没有别的迭代器对对对象进行修改。如果不相等，说明发生了并发的操作，就会抛出一个异常。而有时也会不这样进行判断：

 //删除上一次迭代器越过的元素
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();

            try {
                   //调用需要子类去实现的remove方法
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                //每次删除后，将lastRet置为-1，防止连续的删除
                lastRet = -1;
                //将修改次数赋给迭代器对对象的结构修改次数这个会在下面进行详解
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                //如果出现索引越界，说明发生了并发的操作导致，所以抛出一个并发操作异常。
                throw new ConcurrentModificationException();
            }
        }

这里的设计在于，进行删除操作后，将修改次数和迭代器对象进行同步，虽然在方法的开始进行了checkForComodification()方法的判断，但是担心的是再进行删除操作的时候发生了并发的操作，所以在这里进行了try...catch...的处理，当发生了索引越界的异常的时候，说明一定是发生了并发的操作，所以抛出一个ConcurrentModificationException()。

关于SubList和RandomAccessSubList

通过阅读源码我们可以知道，这个类实际上就是一个啃老族。基本上方法全是直接去加上offset后去调用的父类的方法，而RandomAccessSubList只是在此基础上实现了RandomAccess的接口，而这个接口是干嘛的呢？


package java.util;
/**
 * Marker interface used by <tt>List</tt> implementations to indicate that
 * they support fast (generally constant time) random access.  The primary
 * purpose of this interface is to allow generic algorithms to alter their
 * behavior to provide good performance when applied to either random or
 * sequential access lists.
 */
public interface RandomAccess {
}

通过阅读英文注释后我们可以知道，这个接口仅仅是一个标志性接口，用来标志是否可以随机访问的。

下节预告

接下来，我们终于要接触到第一个真正意义上的实现类了，敬请期待哟~

公众号

Java基础系列（四十二）：集合之AbstractList - 图3