源码(06) -- java.util.AbstractList

java.util.AbstractList<E> 源码分析（JDK1.7）

---------------------------------------------------------------------------------

java.util.AbstractList<E>是一个抽象类，它的定义如下:

 public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
   //constructor

   // Modification Operations

   // Search Operations

   // Bulk Operations

   // Iterators、subList

   // Comparison and hashing

   //inner class 'Itr'

   //inner class 'ListItr'
 }

 class SubList<E> extends AbstractList<E> {
 }

 class RandomAccessSubList<E> extends SubList<E> implements RandomAccess{

 }

(1)从上面可以看出java.util.AbstractList<E>好复杂哟,它不光有那么多的方法，而且还有2个内部类，这都还不算，它的类文件中居然还有两个其它的类(~_~),是不是要醉了，这都要怪它爹java.util.List<E>提供的25个没有实现的方法（@_@）

(2)好了，不废话了，不抱怨了，继续挽起袖子往下干

继续往下面看前,可以先去了解下:

java.util.List<E>接口

java.util.AbstractCollection<E>接口

下面来看看一幅图:

---------------------------------------------------------------------------------

下面来看看java.util.AbstractList<E>中具体有哪些方法：

从下面的表格中可以看出java.util.AbstractList<E>接口中一共有16个方法:其中查询操作3个;修改操作5个;批量操作2个;Iterator和subList操作4个;比较和哈希操作2个;

修改操作	public boolean add(E e)	将指定的元素e添加到集合尾部
	public E set(int index, E element)	将集合中index位置的元素替换为element元素
	public void add(int index, E element)	将指定的元素e添加到集合的index位置
	public E remove(int index)	删除集合中index位置上的元素
	protected void removeRange(int fromIndex,int toIndex)	删除集合中索引在fromIndex(包括)和toIndex(不包括)之间的所有元素
查询操作	public int indexOf(Object o)	返回集合中元素o第一次出现的位置index
	public int lastIndexOf(Object o)	返回集合中元素o最后一次出现的位置idnex
	abstract public E get(int index)	返回集合index位置上的元素
批量操作	public void clear()	清空集合中的元素
	public boolean addAll(int index, Collection<? extends E> c)	将子集合c添加到集合尾部
Iterator和subList操作	public Iterator<E> iterator()	将集合中的元素以Iterator的形式返回
	public ListIterator<E> listIterator()	将集合中的元素以ListIterator的形式返回
	public ListIterator<E> listIterator(final int index)	将集合中的元素以ListIterator的形式返回
	public List<E> subList(int fromIndex, int toIndex)	返回集合中索引在fromIndex(包括)和toIndex(不包括)之间的所有元素
比较和哈希操作	public boolean equals(Object o)	比较对象o与此集合对象是否相等
	public int hashCode()	返回集合对象的hashCode

java.util.AbstractList<E>从java.util.AbstractCollection<E>继承的方法如下:

1. public boolean addAll(Collection<? extends E> c)
2. public boolean contains(Object o)
3. public boolean containsAll(Collection<?> c)
4. public boolean isEmpty()
5. public boolean remove(Object o)
6. public boolean removeAll(Collection<?> c)
7. public boolean retainAll(Collection<?> c)
8. public abstract int size()
9. public Object[] toArray()
10. public <T> T[] toArray(T[] a)
11. public String toString()

java.util.AbstractList<E>从java.util.List<E>继承的方法如下:

1. boolean addAll(int index,Collection<? extends E> c)
2. boolean contains(Object o)
3. boolean containsAll(Collection<?> c)
4. boolean isEmpty()
5. boolean remove(Object o)
6. boolean removeAll(Collection<?> c)
7. boolean retainAll(Collection<?> c)
8. int size()
9. Object[] toArray()
10. <T> T[] toArray(T[] a)

---------------------------------------------------------------------------------

下面来看看java.util.AbstractList<E>中源码部分:

一、构造函数

     protected AbstractList() {
     }

二、具体方法

修改操作

(1) public boolean add(E e)

源代码如下:

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

(2) public E set(int index, E element)

源代码如下:

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

(3) public void add(int index, E element)

源代码如下:

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

(4) public E remove(int index)

源代码如下:

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

(5) protected void removeRange(int fromIndex,int toIndex)

源代码如下:

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

查询操作

(1) public int indexOf(Object o)

源代码如下:

     public int indexOf(Object o) {
         //返回此集合的ListIterator对象
         ListIterator<E> it = listIterator();

         if (o==null) {
             //如果o对象为null,则在ListIterator对象中查找
             while (it.hasNext())
                 if (it.next()==null)
                     return it.previousIndex();
         } else {
             //如果o对象不为null,则在ListIterator对象中查找
             while (it.hasNext())
                 if (o.equals(it.next()))
                     return it.previousIndex();
         }
         return -1;
     }

(2) public int lastIndexOf(Object o)

源代码如下:

     public int lastIndexOf(Object o) {
         //返回集合的ListIterator对象
         ListIterator<E> it = listIterator(size());

         if (o==null) {
             //如果o为null,则在ListIterator中往前查询
             while (it.hasPrevious())
                 if (it.previous()==null)
                     return it.nextIndex();
         } else {
             //如果o为null,则在ListIterator中往前查询
             while (it.hasPrevious())
                 if (o.equals(it.previous()))
                     return it.nextIndex();
         }
         return -1;
     }

(3) abstract public E get(int index)

源代码如下:

 abstract public E get(int index);

批量操作

(1) public void clear()

源代码如下:

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

removeRange(int fromIndex,int toIndex)源代码如下:

     protected void removeRange(int fromIndex, int toIndex) {
         //返回此集合的ListIterator对象
         ListIterator<E> it = listIterator(fromIndex);

         //利用for循环删除集合中索引位置从fromIndex开始到toIndex之间的全部元素
         for (int i=0, n=toIndex-fromIndex; i<n; i++) {
             it.next();
             it.remove();
         }
     }

(2) public boolean addAll(int index, Collection<? extends E> c)

源代码如下:

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

Iterator和subList操作（详情看后面关于java.util.AbstractList<E>内部类的介绍）

(1) public Iterator<E> iterator()

源代码如下:

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

(2) public ListIterator<E> listIterator()

源代码如下:

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

(3) public ListIterator<E> listIterator(final int index)

源代码如下:

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

(4) public List<E> subList(int fromIndex, int toIndex)

源代码如下:

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

比较和哈希操作

(1) public boolean equals(Object o)

源代码如下:

     public boolean equals(Object o) {
         if (o == this)
             return true;
         if (!(o instanceof List))
             return false;

         ListIterator<E> e1 = listIterator();
         ListIterator e2 = ((List) o).listIterator();
         while (e1.hasNext() && e2.hasNext()) {
             E o1 = e1.next();
             Object o2 = e2.next();
             if (!(o1==null ? o2==null : o1.equals(o2)))
                 return false;
         }
         return !(e1.hasNext() || e2.hasNext());
     }

(2) public int hashCode()

源代码如下:

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

----------------------------------------------------------------------------------------

下面来看看java.util.AbstractList<E>中的两个内部类:

内部类 : Itr

类的定义如下:

 private class Itr implements Iterator<E> {
    //属性

    //方法
 }

可以知道内部类Itr实现了Iterator接口(点击查看java.util.Iterator<E>接口的相关信息)

     private class Itr implements Iterator<E> {

         //记录索引位置(这个索引位置就是下次调用next()方法时返回元素的位置)
         int cursor = 0;

         //记录最近调用next()或者previous()方法时返回元素的索引
         //如果调用了remove()方法则将它的值重置为-1
         int lastRet = -1;

         //fast-fail机制标记
         int expectedModCount = modCount;

         //如果仍有元素可以迭代,则返回true
         public boolean hasNext() {
             return cursor != size();
         }

         //返回迭代的下一个元素
         public E next() {
             //检查fast-fail机制
             checkForComodification();
             try {
                 int i = cursor;
                 //调用java.util.AbstractList<E>的get(int index)方法获取集合中index位置的元素值
                 E next = get(i);
                 //设置最近调用next()方法返回元素的索引值
                 lastRet = i;
                 cursor = i + 1;
                 return next;
             } catch (IndexOutOfBoundsException e) {
                 checkForComodification();
                 throw new NoSuchElementException();
             }
         }

         //从迭代器指向的collection中移除迭代器返回的最后一个元素
         public void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();

             //检查fast-fail机制
             checkForComodification();

             try {
                 //删除元素
                 AbstractList.this.remove(lastRet);
                 if (lastRet < cursor)
                     cursor--;
                 //重置为-1
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException e) {
                 throw new ConcurrentModificationException();
             }
         }
         //检查fast-fail机制,如果不满足,则抛出异常
         final void checkForComodification() {
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
         }
     }

内部类 : ListItr

类的定义如下:

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

可以知道内部类ListItr继承了Itr类并且实现了ListIterator接口(点击查看java.util.ListIterator<E>接口的相关信息)

     private class ListItr extends Itr implements ListIterator<E> {
         //带参数构造函数
         ListItr(int index) {
             cursor = index;
         }
         //如果以逆向遍历列表集合,列表迭代器有多个元素,则返回true
         public boolean hasPrevious() {
             return cursor != 0;
         }

         //返回列表集合中前一个元素
         public E previous() {
             //检查fast-fail机制
             checkForComodification();
             try {
                 int i = cursor - 1;
                 //获取前一个元素
                 E previous = get(i);
                 lastRet = cursor = i;
                 return previous;
             } catch (IndexOutOfBoundsException e) {
                 checkForComodification();
                 throw new NoSuchElementException();
             }
         }
         //返回对next的后续调用所返回的元素的索引
         public int nextIndex() {
             return cursor;
         }
         //返回对previous的后续调用所返回元素的索引
         public int previousIndex() {
             return cursor-1;
         }
         //用指定元素替换next或者previous返回的最后一个元素
         public void set(E e) {
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();

             try {
                 AbstractList.this.set(lastRet, e);
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }
         //将指定的元素插入列表
         public void add(E e) {
             checkForComodification();

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

----------------------------------------------------------------------------------------