JAVA迭代器

迭代器（Iterator）

　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

从以上的定义中可以发现，似乎Iterable()接口和Iterator()接口完全一致，没有任何区别。结合刚刚学习的内部类，可以发现这又是一个支持程序多样化的巧妙设计，充分的支持了多态和解耦。

1、由于所有的Collection类型的对象都被强制要求implements  Iterable 接口，故任何Collection对象都要能返回一个能遍历其的迭代器Iterator。如果直接 implement iterator接口， Collection会直接要求具有hasNext（）等方法。但是这种方法不具备多态性，即设定好了该如何执行hasNext()等操作，而且程序会显得十分的臃肿和复杂。但是如果采用实施Iterable()接口和返回Iterator对象的方式，则会全然的不同，只要能够返回Iterator对象，完全可以自己的需要进行遍历方式上的自由定义。（即针对同一个接口，在其实现类中提供多样、不同的方法）。

　　Java中的Iterator功能比较简单，并且只能单向移动：

　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

　　(2) 使用next()获得序列中的下一个元素。

　　(3) 使用hasNext()检查序列中是否还有元素。

　　(4) 使用remove()将迭代器新返回的元素删除。

　　Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

迭代器应用：
 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }
 /*迭代器用于while循环
 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }
 */

从以上的例子中可以发现，为了实现对ScanAppleStore类对象的遍历，共定义了两种迭代器供选择：

1、public Iterator<String> iterator() :该迭代器被定义为ScanAppleStore implements Iterable接口的方法, 采用常规的顺序遍历方式，for(String str:appleTree) 时自动被转型调用。

2、public Iterable<String> reverseIterator()：该迭代器采用了匿名内部类的方式实现Iterable接口，并返回Iterable对象，采用逆序的遍历方式，for(String str:appleTree.reverseIterator())时，通过调用appleTree.reverseIterator()方法返回Iterable对象。

！foreach语法的标准形式为：for(T element : Iterable<T> elements)

由于Iterable接口要求实现iterator()方法，iterator()方法要求返回Iterator对象，Iterator定义了hasNext(), next(), remove()三种必须被实现的方法。

故实现Iterable的稍显拖沓和复杂：

1.Iterator

Java提供一个专门的迭代器<<interface>>Iterator，我们可以对某个序列实现该interface，来提供标准的Java迭代器。Iterator接口实现后的功能是“使用”一个迭代器.

文档定义:

[java] view plaincopyprint?

1. Package java.util;
2. 
   
3. publicinterface Iterator<E> {
4. 
   
5. boolean hasNext();//判断是否存在下一个对象元素
6. 
   
7. E next();
8. 
   
9. void remove();
10. }

[java] view plain copy

 print?

1. <span style="font-size:18px;">Package  java.util;   
2.   
3. public interface Iterator<E> {  
4.   
5.     boolean hasNext();//判断是否存在下一个对象元素  
6.   
7.      E next();  
8.   
9.     void remove();  
10. }  
11. </span>  

2.Iterable

Java中还提供了一个Iterable接口，Iterable接口实现后的功能是“返回”一个迭代器,我们常用的实现了该接口的子接口有: Collection<E>, Deque<E>, List<E>, Queue<E>, Set<E> 等.该接口的iterator()方法返回一个标准的Iterator实现。实现这个接口允许对象成为 Foreach 语句的目标。就可以通过Foreach语法遍历你的底层序列。

Iterable接口包含一个能够产生Iterator的iterator()方法，并且Iterable接口被foreach用来在序列中移动。因此如果创建了任何实现Iterable接口的类，都可以将它用于foreach语句中。

[java] view plaincopyprint?

1. 文档定义:
2. 
   
3. Package java.lang;
4. 
   
5. import java.util.Iterator;
6. public interface Iterable<T> {
7. Iterator<T> iterator();
8. }

[java] view plain copy

 print?

1. <span style="font-size:18px;">文档定义:  
2.   
3. Package  java.lang;   
4.   
5. import  java.util.Iterator;   
6. public interface Iterable<T> {   
7.      Iterator<T> iterator();   
8. }  
9.   
10. </span>  

[java] view plaincopyprint?

1. 使用Iterator的简单例子
2. 
   
3. import java.util.*;
4. 
   
5. publicclass TestIterator {
6. 
   
7. 
   
8. public static void main(String[] args) {
9. 
   
10. 
    
11. 
    
12. List list=new ArrayList();
13. 
    
14. Map map=new HashMap();
15. 
    
16. for(int i=0;i<10;i++){
17. 
    
18. list.add(new String("list"+i) );
19. 
    
20. map.put(i, new String("map"+i));
21. 
    
22. }
23. 
    
24. Iterator iterList= list.iterator();//List接口实现了Iterable接口
25. 
    
26. while(iterList.hasNext()){
27. 
    
28. String strList=(String)iterList.next();
29. 
    
30. System.out.println(strList.toString());
31. 
    
32. }
33. 
    
34. Iterator iterMap=map.entrySet().iterator();
35. 
    
36. while(iterMap.hasNext()){
37. 
    
38. Map.Entry strMap=(Map.Entry)iterMap.next();
39. 
    
40. System.out.println(strMap.getValue());
41. 
    
42. 
    
43. 
    
44. }
45. 
    
46. }
47. 
    
48. }
49. 
    
50. <span style="color: rgb(0, 0, 153); font-size: 18px;"> </span><span style="color: rgb(0, 0, 153); font-size: 18px;"></span>

[java] view plain copy

 print?

1. <span style="font-size:18px;">使用Iterator的简单例子  
2.   
3. import java.util.*;  
4.   
5. public class TestIterator {  
6.   
7.   
8.    public static void main(String[] args) {  
9.   
10.           
11.   
12.       List list=new ArrayList();  
13.   
14.       Map map=new HashMap();  
15.   
16.       for(int i=0;i<10;i++){  
17.   
18.           list.add(new String("list"+i) );  
19.   
20.           map.put(i, new String("map"+i));  
21.   
22.       }  
23.   
24.       Iterator iterList= list.iterator();//List接口实现了Iterable接口  
25.   
26.         while(iterList.hasNext()){  
27.   
28.           String strList=(String)iterList.next();  
29.   
30.           System.out.println(strList.toString());  
31.   
32.       }  
33.   
34.       Iterator iterMap=map.entrySet().iterator();  
35.   
36.       while(iterMap.hasNext()){  
37.   
38.           Map.Entry  strMap=(Map.Entry)iterMap.next();  
39.   
40.           System.out.println(strMap.getValue());  
41.   
42.    
43.   
44.       }  
45.   
46.    }  
47.   
48. }  
49.   
50.  <span style="color:#0099;">  </span><span style="color:#0099;"></span> </span>  

接口Iterator在不同的子接口中会根据情况进行功能的扩展,例如针对List的迭代器ListIterator,该迭代器只能用于各种List类的访问。ListIterator可以双向移动。添加了previous()等方法.

3 Iterator与泛型搭配

Iterator对集合类中的任何一个实现类，都可以返回这样一个Iterator对象。可以适用于任何一个类。

因为集合类(List和Set等)可以装入的对象的类型是不确定的,从集合中取出时都是Object类型,用时都需要进行强制转化,这样会很麻烦,用上泛型,就是提前告诉集合确定要装入集合的类型,这样就可以直接使用而不用显示类型转换.非常方便.

4.foreach和Iterator的关系

for each是jdk5.0新增加的一个循环结构，可以用来处理集合中的每个元素而不用考虑集合定下标。

格式如下 

for(variable:collection){ statement; }

定义一个变量用于暂存集合中的每一个元素，并执行相应的语句(块)。collection必须是一个数组或者是一个实现了lterable接口的类对象。 

[java] view plaincopyprint?

1. 上面的例子使用泛型和forEach的写法:
2. 
   
3. import java.util.*;
4. public class TestIterator {
5. 
   
6. 
   
7. 
   
8. public static void main(String[] args) {
9. 
   
10. 
    
11. 
    
12. List<String> list=new ArrayList<String> ();
13. 
    
14. for(int i=0;i<10;i++){
15. 
    
16. list.add(new String("list"+i) );
17. 
    
18. }
19. 
    
20. for(String str:list){
21. 
    
22. System.out.println(str);
23. 
    
24. }
25. 
    
26. }

[java] view plain copy

 print?

1. <span style="font-size:18px;">上面的例子使用泛型和forEach的写法:  
2.   
3. import java.util.*;  
4. public class TestIterator {  
5.   
6.   
7.   
8.    public static void main(String[] args) {  
9.   
10.           
11.   
12.       List<String>  list=new ArrayList<String> ();  
13.   
14.       for(int i=0;i<10;i++){  
15.   
16.           list.add(new String("list"+i) );  
17.   
18.       }  
19.   
20.       for(String str:list){  
21.   
22.         System.out.println(str);  
23.   
24.       }    
25.   
26. }  
27.   
28. </span>  

可以看出,使用for each循环语句的优势在于更加简洁，更不容易出错，不必关心下标的起始值和终止值。

forEach不是关键字,关键字还是for,语句是由iterator实现的，他们最大的不同之处就在于remove()方法上。

一般调用删除和添加方法都是具体集合的方法，例如：

List list = new ArrayList(); list.add(...); list.remove(...);

但是，如果在循环的过程中调用集合的remove()方法，就会导致循环出错，因为循环过程中list.size()的大小变化了，就导致了错误。 所以，如果想在循环语句中删除集合中的某个元素，就要用迭代器iterator的remove()方法，因为它的remove()方法不仅会删除元素，还会维护一个标志，用来记录目前是不是可删除状态，例如，你不能连续两次调用它的remove()方法，调用之前至少有一次next()方法的调用。

forEach就是为了让用iterator循环访问的形式简单，写起来更方便。当然功能不太全,所以但如有删除操作，还是要用它原来的形式。

4 使用for循环与使用迭代器iterator的对比

效率上的各有优势

   采用ArrayList对随机访问比较快，而for循环中的get()方法，采用的即是随机访问的方法，因此在ArrayList里，for循环较快

   采用LinkedList则是顺序访问比较快，iterator中的next()方法，采用的即是顺序访问的方法，因此在LinkedList里，使用iterator较快

从数据结构角度分析,for循环适合访问顺序结构,可以根据下标快速获取指定元素.而Iterator 适合访问链式结构,因为迭代器是通过next()和Pre()来定位的.可以访问没有顺序的集合.

而使用 Iterator 的好处在于可以使用相同方式去遍历集合中元素，而不用考虑集合类的内部实现（只要它实现了 java.lang.Iterable 接口），如果使用 Iterator 来遍历集合中元素，一旦不再使用 List 转而使用 Set 来组织数据，那遍历元素的代码不用做任何修改，如果使用 for 来遍历，那所有遍历此集合的算法都得做相应调整,因为List有序,Set无序,结构不同,他们的访问算法也不一样.