JDK源碼(1.7) -- java.util.AbstractList


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>繼承的方法如下:

  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>中源碼部分:

一、構造函數

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     }

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

 

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com