Java 迭代器

迭代器（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中插入和删除元素。

 

 

由于Java中数据容器众多，而对数据容器的操作在很多时候都具有极大的共性，于是Java采用了迭代器为各种容器提供公共的操作接口。

使用Java的迭代器iterator可以使得对容器的遍历操作完全与其底层相隔离，可以到达极好的解耦效果。

 public interface Iterable<T>

　　 Iterator<T> iterator() 
          Returns an iterator over a set of elements of type T

 

Collection接口拓展了接口Iterable，根据以上的对Iterable接口的定义可以发现，其要求实现其的类都提供一个返回迭代器Iterator<T>对象的方法。

迭代器Iterator<T>接口的的定义为：

Interface Iterator<E>

boolean  hasNext() 
          Returns true if the iteration has more elements.

 E  next() 
          Returns the next element in the iteration.

void  remove() 
          Removes from the underlying collection the last element returned by the iterator (optional operation).

注意：

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

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

Example:

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
public class TestIterable {
    TestIterable(){
    ScanAppleStore appleTree= new ScanAppleStore();
     
    print("Try normal iterator:");
    for(String str:appleTree)
    {
        print(str);
         
    }
    print("Try reverse iterator:");
    for(String str:appleTree.reverseIterator())
    {
        print(str);
    }
    }
}
 
class ScanAppleStore implements Iterable<String>
{
    ArrayList<String> appleStore = new ArrayList<String>();
    ScanAppleStore()
    {
        Collections.addAll(appleStore,"Sweet","Sour","Bitter","litter Sweet","litter Sour","litter Bitter");
        print(appleStore);
    }
    public Iterator<String> iterator()
    {
        return new Iterator<String>(){
            private int i=0;
            public boolean hasNext()
            {
                if(i<appleStore.size())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            public String next()
            {
 
                return appleStore.get(i++);
            }
            public void remove()
            {
                print("not defined!");
            }
        };
    }
    public Iterable<String> reverseIterator()
    {
        return new Iterable<String>()
        {
            public Iterator<String> iterator(){
                return new Iterator<String>(){
            private int i=appleStore.size()-1;
            public boolean hasNext()
            {
                if(i>-1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            public String next()
            {
 
                return appleStore.get(i--);
            }
            public void remove()
            {
                print("not defined!");
            }
                };
            }
            };
 
    }
}

从以上的例子中可以发现，为了实现对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的稍显拖沓和复杂：

Example：

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<span>public Iterable<String> reverseIterator()
    {
        return new Iterable<String>()
        {
            public Iterator<String> iterator(){
                return new Iterator<String>(){</span>
            private int i=appleStore.size()-1;
            public boolean hasNext()
            {
                if(i>-1)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            public String next()
            {
 
                return appleStore.get(i--);
            }
            public void remove()
            {
                print("not defined!");
            }
                };
            }
            };
 
    }
}

此处采用了匿名内部类的方式，结构十分的清晰，此处更是体现出了内部类对于实现接口，强化OOP Java编程能力的重要性。

注意Iterable<T>中强调使用范型，故在定义的时候一定要注意指明类型。

 

 

迭代器接口要求实现其的类必须提供三种方法：

hasNext() ：遍历过程中，判定是否还有下一个元素。（从Collection对象的第一个元素开始）

next() : 遍历该元素。(即取出下一个元素)

remove(): 移除刚刚遍历过的元素。

从定义可以发现，该三个方法经常是被搭配使用的。

Examle:

Iteraotr it= arrayList.Iterator();

while(it.hasNext())

{

　　print(it.next());

      it.remove();

}

基本思路为：在遍历下一个元素前，先判断其是否存在。对于想删除的元素，必须先遍历其，故 remove()方法总是接在 next()方法之后。

 

From：http://www.cnblogs.com/airwindow/archive/2012/06/25/2560811.html

 

posted on 2016-07-25 15:24  alvin.zhang  阅读(257)  评论(0)  编辑  收藏  举报

导航