我在裏面補充了一些知識點和註解,不用你們去百度了。
迭代器模式:就是提供一種方法對一個容器對象中的各個元素進行訪問,而又不暴露該對象容器的內部細節。
概述
Java集合框架的集合類,我們有時候稱之爲容器。容器的種類有很多種,比如ArrayList、LinkedList、HashSet...,每種容器都有自己的特點,ArrayList底層維護的是一個數組;LinkedList是鏈表結構的;HashSet依賴的是哈希表,每種容器都有自己特有的數據結構。
因爲容器的內部結構不同,很多時候可能不知道該怎樣去遍歷一個容器中的元素。所以爲了使對容器內元素的操作更爲簡單,Java引入了迭代器模式!
把訪問邏輯從不同類型的集合類中抽取出來,從而避免向外部暴露集合的內部結構。
對於數組我們使用的是下標來進行處理的:
1 int array[] = new int[3];
2 for (int i = 0; i < array.length; i++) {
3 System.out.println(array[i]);
4 }
對ArrayList的處理
1 List<String> list = new ArrayList<String>();
2 for(int i = 0 ; i < list.size() ; i++){
3 String string = list.get(i);
4 }
對於這兩種方式,我們總是都知道它的內部結構,訪問代碼和集合本身是緊密耦合的,無法將訪問邏輯從集合類和客戶端代碼中分離出來。不同的集合會對應不同的遍歷方法,客戶端代碼無法複用。在實際應用中如何將上面兩個集合整合是相當麻煩的。所以纔有Iterator,它總是用同一種邏輯來遍歷集合。使得客戶端自身不需要來維護集合的內部結構,所有的內部狀態都由Iterator來維護。客戶端不用直接和集合進行打交道,而是控制Iterator向它發送向前向後的指令,就可以遍歷集合。
1.java.util.Iterator
下面讓我們看看Java中的Iterator接口是如何實現的
在Java中Iterator爲一個接口,它只提供了迭代的基本規則。在JDK中它是這樣定義的:對Collection進行迭代的迭代器。迭代器取代了Java Collection Framework中的Enumeration。迭代器與枚舉有兩點不同:
1. 迭代器在迭代期間可以從集合中移除元素。(也可以說迭代器比枚舉器多了一個刪除數據的方法,枚舉器只能獲取元素)
2. 方法名得到了改進,Enumeration的方法名稱都比較長。
3. Iterator支持fail-fast機制,而Enumeration不支持。(多線程時,對同一個集合,一邊遍歷,一邊添加刪除(這裏是說集合本身的增刪方法,不是指迭代器或枚舉器),迭代器會報錯,提示這樣做是線程不安全的;而枚舉器不會報錯,程序可以繼續執行)
其接口定義如下:
package java.util;
public interface Iterator<E> {
boolean hasNext();//判斷是否存在下一個對象元素
E next();//獲取下一個元素
void remove();//移除元素
}
這裏要補充下枚舉器(Enumeration)的概念:
Enumeration是java.util中的一個接口類,在Enumeration中封裝了有關枚舉數據集合的方法,與Iterator差不多,用來遍歷集合中的元素,但是枚舉Enumeration只提供了遍歷Vector和Hashtable集合元素的功能,這種類型的集合對象通過調用elements()方法構造一個Enumeration對象,然後Enumeratino對象再調用以下方法來對集合中的元素進行遍歷。
hasMoreElements():判斷Enumeration對象中是否還有數據
nextElement():獲取Enumeration對象中的下一個數據
2.Iterable
Java中還提供了一個Iterable接口,Iterable接口實現後的功能是‘返回’一個迭代器,我們常用的實現了該接口的子接口有:Collection<E>、List<E>、Set<E>等。該接口的iterator()方法返回一個標準的Iterator實現。實現Iterable接口允許對象成爲Foreach語句的目標。就可以通過foreach語句來遍歷你的底層序列。
Iterable接口包含一個能產生Iterator對象的方法,並且Iterable被foreach用來在序列中移動。因此如果創建了實現Iterable接口的類,都可以將它用於foreach中。
Iterable接口的具體實現:
Package java.lang;
import java.util.Iterator;
public interface Iterable<T> {
Iterator<T> iterator();
}
使用迭代器遍歷集合:
1 public static void main(String[] args) {
2 List<String> list = new ArrayList<String>();
3 list.add("張三1");
4 list.add("張三2");
5 list.add("張三3");
6 list.add("張三4");
7
8 List<String> linkList = new LinkedList<String>();
9 linkList.add("link1");
10 linkList.add("link2");
11 linkList.add("link3");
12 linkList.add("link4");
13
14 Set<String> set = new HashSet<String>();
15 set.add("set1");
16 set.add("set2");
17 set.add("set3");
18 set.add("set4");
19 //使用迭代器遍歷ArrayList集合
20 Iterator<String> listIt = list.iterator();
21 while(listIt.hasNext()){
22 System.out.println(listIt.hasNext());
23 }
24 //使用迭代器遍歷Set集合
25 Iterator<String> setIt = set.iterator();
26 while(setIt.hasNext()){
27 System.out.println(listIt.hasNext());
28 }
29 //使用迭代器遍歷LinkedList集合
30 Iterator<String> linkIt = linkList.iterator();
31 while(linkIt.hasNext()){
32 System.out.println(listIt.hasNext());
33 }
34 }
使用foreach遍歷集合:
List<String> list = new ArrayList<String>();
list.add("張三1");
list.add("張三2");
list.add("張三3");
list.add("張三4");
for (String string : list) {
System.out.println(string);
}
可以看出使用foreach遍歷集合的優勢在於代碼更加的簡潔,更不容易出錯,不用關心下標的起始值和終止值。
3.Iterator遍歷時不可以刪除集合中的元素問題
在使用Iterator的時候禁止對所遍歷的容器進行改變其大小結構的操作。例如: 在使用Iterator進行迭代時,如果對集合進行了add、remove操作就會出現ConcurrentModificationException異常。
1 List<String> list = new ArrayList<String>();
2 list.add("張三1");
3 list.add("張三2");
4 list.add("張三3");
5 list.add("張三4");
6
7 //使用迭代器遍歷ArrayList集合
8 Iterator<String> listIt = list.iterator();
9 while(listIt.hasNext()){
10 Object obj = listIt.next();
11 if(obj.equals("張三3")){
12 list.remove(obj);
13 }
14 }
因爲在你迭代之前,迭代器已經被通過list.itertor()創建出來了(迭代器中元素和集合中元素一一對應),如果在迭代的過程中,又對list進行了改變其容器大小的操作,那麼Java就會給出異常。因爲此時Iterator對象已經無法主動同步list做出的改變,Java會認爲你做出這樣的操作是線程不安全的,就會給出善意的提醒(拋出ConcurrentModificationException異常)
Iterator的實現源碼:
1 private class Itr implements Iterator<E> {
2 int cursor; // index of next element to return
3 int lastRet = -1; // index of last element returned; -1 if no such
4 int expectedModCount = modCount;
5
6 public boolean hasNext() {
7 return cursor != size;
8 }
9
10 @SuppressWarnings("unchecked")
11 public E next() {
12 checkForComodification();
13 int i = cursor;
14 if (i >= size)
15 throw new NoSuchElementException();
16 Object[] elementData = ArrayList.this.elementData;
17 if (i >= elementData.length)
18 throw new ConcurrentModificationException();
19 cursor = i + 1;
20 return (E) elementData[lastRet = i];
21 }
22
23 public void remove() {
24 if (lastRet < 0)
25 throw new IllegalStateException();
26 checkForComodification();
27
28 try {
29 ArrayList.this.remove(lastRet);
30 cursor = lastRet;
31 lastRet = -1;
32 expectedModCount = modCount;
33 } catch (IndexOutOfBoundsException ex) {
34 throw new ConcurrentModificationException();
35 }
36 }
37
38 final void checkForComodification() {
39 if (modCount != expectedModCount)
40 throw new ConcurrentModificationException();
41 }
42 }
通過查看源碼發現原來檢查並拋出異常的是checkForComodification()方法。在ArrayList中modCount是當前集合的版本號,每次修改(增、刪)集合都會加1;expectedModCount是當前迭代器的版本號,在迭代器實例化時初始化爲modCount。我們看到在checkForComodification()方法中就是在驗證modCount的值和expectedModCount的值是否相等,所以當你在調用了ArrayList.add()或者ArrayList.remove()時,只更新了modCount的狀態,而迭代器中的expectedModCount未同步,因此纔會導致再次調用Iterator.next()方法時拋出異常。但是爲什麼使用Iterator.remove()就沒有問題呢?通過源碼的第32行發現,在Iterator的remove()中同步了expectedModCount的值,所以當你下次再調用next()的時候,檢查不會拋出異常。
使用該機制的主要目的是爲了實現ArrayList中的快速失敗機制(fail-fast),在Java集合中較大一部分集合是存在快速失敗機制的(java.util包下的集合類都是快速失敗的)。
快速失敗機制產生的條件:當多個線程對Collection進行操作時,若其中某一個線程通過Iterator遍歷集合時,該集合的內容被其他線程所改變,則會拋出ConcurrentModificationException異常。
所以要保證在使用Iterator遍歷集合的時候不出錯誤,就應該保證在遍歷集合的過程中不會對集合產生結構上的修改。
補充一個知識點:
安全失敗(fail—safe)
採用安全失敗機制的集合容器,在遍歷時不是直接在集合內容上訪問的,而是先複製原有集合內容,在拷貝的集合上進行遍歷。
原理:由於迭代時是對原集合的拷貝進行遍歷,所以在遍歷過程中對原集合所作的修改並不能被迭代器檢測到,所以不會觸發Concurrent Modification Exception。
缺點:基於拷貝內容的優點是避免了Concurrent Modification Exception,但同樣地,迭代器並不能訪問到修改後的內容,即:迭代器遍歷的是開始遍歷那一刻拿到的集合拷貝,在遍歷期間原集合發生的修改迭代器是不知道的。
場景:java.util.concurrent包下的容器都是安全失敗,可以在多線程下併發使用,併發修改。
使用Foreach時對集合的結構進行修改會出現異常:
上面我們說了實現了Iterable接口的類就可以通過Foreach遍歷,那是因爲foreach要依賴於Iterable接口返回的Iterator對象,所以從本質上來講,Foreach其實就是在使用迭代器,在使用foreach遍歷時對集合的結構進行修改,和在使用Iterator遍歷時對集合結構進行修改本質上是一樣的。所以同樣的也會拋出異常,執行快速失敗機制。
foreach是JDK1.5新增加的一個循環結構,foreach的出現是爲了簡化我們遍歷集合的行爲。
for循環與迭代器的對比:
* 效率上各有各的優勢:
> ArrayList對隨機訪問比較快,而for循環中使用的get()方法,採用的即是隨機訪問的方法,因此在ArrayList裏for循環快。
> LinkedList則是順序訪問比較快,Iterator中的next()方法採用的是順序訪問方法,因此在LinkedList裏使用Iterator較快。
> 主要還是要依據集合的數據結構不同的判斷。
轉載:https://www.cnblogs.com/zyuze/p/7726582.html