源码(06) -- java.util.AbstractList<E>

 1 public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
 2   //constructor
 3 
 4   // Modification Operations
 5 
 6   // Search Operations
 7 
 8   // Bulk Operations
 9 
10   // Iterators、subList
11 
12   // Comparison and hashing
13 
14   //inner class ‘Itr‘
15 
16   //inner class ‘ListItr‘
17 }
18 
19 class SubList<E> extends AbstractList<E> {
20 }
21 
22 class RandomAccessSubList<E> extends SubList<E> implements RandomAccess{
23 
24 }

1     protected AbstractList() {
2     }

1     public boolean add(E e) {
2         //内部调用了add(int index,E e)方法
3         add(size(), e);
4         return true;
5     }

1     public E set(int index, E element) {
2         //直接抛出异常,需要由子类重新此方法
3         throw new UnsupportedOperationException();
4     }

1     public void add(int index, E element) {
2         //直接抛出异常,需要由子类重写此方法
3         throw new UnsupportedOperationException();
4     }

1     public E remove(int index) {
2         //直接抛出异常,需要由子类重写此方法
3         throw new UnsupportedOperationException();
4     }

1     protected void removeRange(int fromIndex, int toIndex) {
2         //返回集合对象从索引fromIndex位置开始的ListIterator对象
3         ListIterator<E> it = listIterator(fromIndex);
4         //循环上面的ListIterator对象进行删除
5         for (int i=0, n=toIndex-fromIndex; i<n; i++) {
6             it.next();
7             it.remove();
8         }
9     }

 1     public int indexOf(Object o) {
 2         //返回此集合的ListIterator对象
 3         ListIterator<E> it = listIterator();
 4 
 5         if (o==null) {
 6             //如果o对象为null,则在ListIterator对象中查找
 7             while (it.hasNext())
 8                 if (it.next()==null)
 9                     return it.previousIndex();
10         } else {
11             //如果o对象不为null,则在ListIterator对象中查找
12             while (it.hasNext())
13                 if (o.equals(it.next()))
14                     return it.previousIndex();
15         }
16         return -1;
17     }

 1     public int lastIndexOf(Object o) {
 2         //返回集合的ListIterator对象
 3         ListIterator<E> it = listIterator(size());
 4 
 5         if (o==null) {
 6             //如果o为null,则在ListIterator中往前查询
 7             while (it.hasPrevious())
 8                 if (it.previous()==null)
 9                     return it.nextIndex();
10         } else {
11             //如果o为null,则在ListIterator中往前查询
12             while (it.hasPrevious())
13                 if (o.equals(it.previous()))
14                     return it.nextIndex();
15         }
16         return -1;
17     }

1 abstract public E get(int index);

1     public void clear() {
2         //调用内部方法removeRange()来完成的
3         removeRange(0, size());
4     }

 1     protected void removeRange(int fromIndex, int toIndex) {
 2         //返回此集合的ListIterator对象
 3         ListIterator<E> it = listIterator(fromIndex);
 4 
 5         //利用for循环删除集合中索引位置从fromIndex开始到toIndex之间的全部元素
 6         for (int i=0, n=toIndex-fromIndex; i<n; i++) {
 7             it.next();
 8             it.remove();
 9         }
10     }

 1     public boolean addAll(int index, Collection<? extends E> c) {
 2         //检查参数index是否合法
 3         rangeCheckForAdd(index);
 4         boolean modified = false;
 5         //利用for循环依次取出子集合c中的元素,然后添加调用add(int index,E e)方法将元素添加到集合中
 6         for (E e : c) {
 7             add(index++, e);
 8             modified = true;
 9         }
10         return modified;
11     }

1     public Iterator<E> iterator() {
2         //每次调用iterator方法都会去new一个Itr类的实例
3         return new Itr();
4     }

1     public ListIterator<E> listIterator() {
2         //内部是去调用listIterator(int index)方法
3         return listIterator(0);
4     }

1  public ListIterator<E> listIterator(final int index) {
2         //检测参数index是否合法
3         rangeCheckForAdd(index);
4         //new一个ListItr类实例
5         return new ListItr(index);
6     }

1     public List<E> subList(int fromIndex, int toIndex) {
2         //如果此集合有RandomAccess接口标记,则new一个 RandomAccessSubList类实例,否则就new一个SubList类实例
3         return (this instanceof RandomAccess ?
4                 new RandomAccessSubList<>(this, fromIndex, toIndex) :
5                 new SubList<>(this, fromIndex, toIndex));
6     }

 1     public boolean equals(Object o) {
 2         if (o == this)
 3             return true;
 4         if (!(o instanceof List))
 5             return false;
 6 
 7         ListIterator<E> e1 = listIterator();
 8         ListIterator e2 = ((List) o).listIterator();
 9         while (e1.hasNext() && e2.hasNext()) {
10             E o1 = e1.next();
11             Object o2 = e2.next();
12             if (!(o1==null ? o2==null : o1.equals(o2)))
13                 return false;
14         }
15         return !(e1.hasNext() || e2.hasNext());
16     }

1     public int hashCode() {
2         int hashCode = 1;
3         for (E e : this)
4             hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
5         return hashCode;
6     }

1 private class Itr implements Iterator<E> {
2    //属性
3 
4    //方法
5 }

 1     private class Itr implements Iterator<E> {
 2 
 3         //记录索引位置(这个索引位置就是下次调用next()方法时返回元素的位置)
 4         int cursor = 0;
 5 
 6         //记录最近调用next()或者previous()方法时返回元素的索引
 7         //如果调用了remove()方法则将它的值重置为-1
 8         int lastRet = -1;
 9 
10         //fast-fail机制标记
11         int expectedModCount = modCount;
12 
13         //如果仍有元素可以迭代,则返回true
14         public boolean hasNext() {
15             return cursor != size();
16         }
17 
18         //返回迭代的下一个元素
19         public E next() {
20             //检查fast-fail机制
21             checkForComodification();
22             try {
23                 int i = cursor;
24                 //调用java.util.AbstractList<E>的get(int index)方法获取集合中index位置的元素值
25                 E next = get(i);
26                 //设置最近调用next()方法返回元素的索引值
27                 lastRet = i;
28                 cursor = i + 1;
29                 return next;
30             } catch (IndexOutOfBoundsException e) {
31                 checkForComodification();
32                 throw new NoSuchElementException();
33             }
34         }
35         
36         //从迭代器指向的collection中移除迭代器返回的最后一个元素
37         public void remove() {
38             if (lastRet < 0)
39                 throw new IllegalStateException();
40 
41             //检查fast-fail机制
42             checkForComodification();
43 
44             try {
45                 //删除元素
46                 AbstractList.this.remove(lastRet);
47                 if (lastRet < cursor)
48                     cursor--;
49                 //重置为-1
50                 lastRet = -1;
51                 expectedModCount = modCount;
52             } catch (IndexOutOfBoundsException e) {
53                 throw new ConcurrentModificationException();
54             }
55         }
56         //检查fast-fail机制,如果不满足,则抛出异常
57         final void checkForComodification() {
58             if (modCount != expectedModCount)
59                 throw new ConcurrentModificationException();
60         }
61     }

1 private class ListItr extends Itr implements ListIterator<E> {
2    //方法
3 }

 1     private class ListItr extends Itr implements ListIterator<E> {
 2         //带参数构造函数
 3         ListItr(int index) {
 4             cursor = index;
 5         }
 6         //如果以逆向遍历列表集合,列表迭代器有多个元素,则返回true
 7         public boolean hasPrevious() {
 8             return cursor != 0;
 9         }
10 
11         //返回列表集合中前一个元素
12         public E previous() {
13             //检查fast-fail机制
14             checkForComodification();
15             try {
16                 int i = cursor - 1;
17                 //获取前一个元素
18                 E previous = get(i);
19                 lastRet = cursor = i;
20                 return previous;
21             } catch (IndexOutOfBoundsException e) {
22                 checkForComodification();
23                 throw new NoSuchElementException();
24             }
25         }
26         //返回对next的后续调用所返回的元素的索引
27         public int nextIndex() {
28             return cursor;
29         }
30         //返回对previous的后续调用所返回元素的索引
31         public int previousIndex() {
32             return cursor-1;
33         }
34         //用指定元素替换next或者previous返回的最后一个元素
35         public void set(E e) {
36             if (lastRet < 0)
37                 throw new IllegalStateException();
38             checkForComodification();
39 
40             try {
41                 AbstractList.this.set(lastRet, e);
42                 expectedModCount = modCount;
43             } catch (IndexOutOfBoundsException ex) {
44                 throw new ConcurrentModificationException();
45             }
46         }
47         //将指定的元素插入列表
48         public void add(E e) {
49             checkForComodification();
50 
51             try {
52                 int i = cursor;
53                 AbstractList.this.add(i, e);
54                 lastRet = -1;
55                 cursor = i + 1;
56                 expectedModCount = modCount;
57             } catch (IndexOutOfBoundsException ex) {
58                 throw new ConcurrentModificationException();
59             }
60         }
61     }