zoukankan html css js c++ java

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

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

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

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)从上面可以看出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>继承的方法如下:

public boolean addAll(Collection<? extends E> c)
public boolean contains(Object o)
public boolean containsAll(Collection<?> c)
public boolean isEmpty()
public boolean remove(Object o)
public boolean removeAll(Collection<?> c)
public boolean retainAll(Collection<?> c)
public abstract int size()
public Object[] toArray()
public <T> T[] toArray(T[] a)
public String toString()

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

boolean addAll(int index,Collection<? extends E> c)
boolean contains(Object o)
boolean containsAll(Collection<?> c)
boolean isEmpty()
boolean remove(Object o)
boolean removeAll(Collection<?> c)
boolean retainAll(Collection<?> c)
int size()
Object[] toArray()
<T> T[] toArray(T[] a)

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

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

一、构造函数

1     protected AbstractList() {
2     }

二、具体方法

修改操作

(1) public boolean add(E e)

源代码如下:

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

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

源代码如下:

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

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

源代码如下:

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

(4) public E remove(int index)

源代码如下:

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

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

源代码如下:

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)

源代码如下:

 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     }

(2) public int lastIndexOf(Object o)

源代码如下:

 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     }

(3) abstract public E get(int index)

源代码如下:

1 abstract public E get(int index);

批量操作

(1) public void clear()

源代码如下:

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

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

 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     }

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

源代码如下:

 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     }

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

(1) public Iterator<E> iterator()

源代码如下:

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

(2) public ListIterator<E> listIterator()

源代码如下:

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

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

源代码如下:

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

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

源代码如下:

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)

源代码如下:

 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     }

(2) public int hashCode()

源代码如下:

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     }

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

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

内部类 : Itr

类的定义如下:

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

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

 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     }

内部类 : ListItr

类的定义如下:

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

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

 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     }

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

查看全文

相关阅读:
shiro权限框架-鉴权
 shiro权限框架-入门基础
 linux debian,ubuntu WEB API 测试工具 insomnia
java spring 用户等级乘阶算法
 pearadmin 开源后台
 一语中的快速了解ClickHouse
mysql tree树结构
 MySQL 索引优化 btree hash rtree
中断与异常详解（五）
中断与异常（四）

原文地址：https://www.cnblogs.com/xinhuaxuan/p/6346629.html