Iterator和Iterable都是接口。
好多集合类，比如List一族或者Set一族，都实现了Iterable接口，这样对象就可以调用iterator()方法。
package hodling;
import java.util.Iterator;
import static utils.Print.print;
public class IterableClass implements Iterable<String> {
private String[] strings = "Abd this is how we know the Earth to be banna-shaped".split(" ");
public Iterator <String> iterator() {
// private int index = 0; 只有在class里定义的变量可以改变权限，方法里面的变量都是局部变量，不可以改变权限
return new Iterator() {
private int index = 0;
public boolean hasNext() {
return index < strings.length;
}
public String next() {
return strings[index++];
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public static void main(String[] args){
for(String s : new IterableClass()){
print(s);
}
}
}
一般都是结合着用，比如 HashMap类就实现了Iterable接口，而要访问或打印出Map中所有内容时，就可以这样：
HashMap hashMap;
Iterator iter = hashMap.iterator();
while(iter.hashNext()) {
String s = iter.next();
}
那么Iterator和Iterable有什么区别呢，Iterable中有个iterator()方法可以产生Iterator类型的接口，为什么要这么做，而不是让集合类直接实现iterator接口呢？
因为Iterator接口的核心方法next()或者hasNext() 是依赖于迭代器的当前迭代位置的。 如果Collection直接实现Iterator接口，势必导致集合对象中包含当前迭代位置的数据(指针)。 当集合在不同方法间被传递时，由于当前迭代位置不可预置，那么next()方法的结果会变成不可预知。 除非再为Iterator接口添加一个reset()方法，用来重置当前迭代位置。但即时这样，Collection也只能同时存在一个当前迭代位置，而Iterable则不然，每次调用都会返回一个从头开始计数的迭代器，多个迭代器是互不干扰的。
JavaSE5引入了新接口Iterable，该接口包含一个能够产生Iterator接口的iterator()方法，并且Iterable对象被foreach用来在序列中移动，因此创建的任何实现了Iterable接口的类都可以将它用于foreach。
例1 : 继承Iterable并覆盖iterator方法，只能得到一种迭代器。
package hodling;
import java.util.Iterator;
import static utils.Print.print;
public class IterableClass implements Iterable<String> {
private String[] strings = "Abd this is how we know the Earth to be banna-shaped".split(" ");
public Iterator <String> iterator() {
// private int index = 0; 只有在class里定义的变量可以改变权限，方法里面的变量都是局部变量，不可以改变权限
return new Iterator() {
private int index = 0;
public boolean hasNext() {
return index < strings.length;
}
public String next() {
return strings[index++];
}
public void remove() {
throw new UnsupportedOperationException();
}
};
}
public static void main(String[] args){
for(String s : new IterableClass()){
print(s);
}
}
}
- 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
为什么要在Iterable接口中再定义一个 Iterator iterator()方法呢？
让迭代逻辑和数据结构分离开来（从例1可以看出，Iterable是一个数据结构，而Iterator是一个迭代器），这样做可以在一种数据结构上定义多种迭代逻辑（如下例2所示）。
- Iterable接口：从继承结构中可以看出，Iterable接口是Collection的顶层接口，所以Iterable是数据结构，用来存放数据的地方。
- Iterator接口：是定义了迭代逻辑的接口，即：用于遍历Collection（集合类）中数据的标准访问方法。
例2: 现在有一个Iterable类，你想要添加一种或者多种在foreach语句中使用这个类的方法，比如：你希望可以向前、向后和随机迭代一个单词列表。应该如何解决（因为继承Iterable并覆盖iterator方法，只能实现向前或者向后中的一种迭代器，就像例1）？
适配器方法：给类添加可以产生Iteratble对象的方法“前向迭代器”、“反向迭代器”和“随机迭代器”，让产生的对象可以用于foreach语句。
package hodling;
import java.util.Iterator;
import java.util.Random;
import static utils.Print.*;
public class MultiIterableClass extends IterableClass {
private String[] strings = "this And that is how we konw the truth !".split(" ");
// 只是用来证明public proteect和包访问访问控制权限的方法和域都可以被继承到导出类中，并且可以通过super访问基类中的方法和域；
// void f()1{
// print(this.strings.toString());
// print(super.strings.toString());
// super.iterator();
// }
//为什么要在Iterable和Iterator后面加范型？查看Iterable和Iterator接口的源码可以知道，它们是范型<T>接口（这就是容器的设计思想，让容器持有某种特定类型），是为了next返回相应的类型<T>，
public Iterable<String> revesed(){
return new Iterable<String>(){
public Iterator<String> iterator(){
return new Iterator<String>(){
private int index = strings.length-1;
public boolean hasNext(){
return index >= 0;
}
public String next(){
return strings[index--];
}
public void remove(){
throw new UnsupportedOperationException();
}
};
}
};
}
public Iterable<String> random(int sz){
return new Iterable<String>(){
public Iterator<String> iterator(){
return new Iterator<String>() {
private int index = 0;
Random random = new Random();
@Override
public boolean hasNext() {
return index++<sz;
}
@Override
public String next() {
return strings[random.nextInt(strings.length)];
}
};
}
};
}
public Iterator<String> iterator(){
return new Iterator<String>(){
private int index = 0;
public boolean hasNext(){
return index < strings.length;
}
public String next(){
return strings[index++];
}
public void remove(){
throw new UnsupportedOperationException();
}
};
}
//多态：从父类继承来的方法，必须重新实现一遍，否则就会访问父类的域。但是getClass例外，getClass：Returns the runtime class of this
// public void f(){
// print(getClass().getSimpleName()+" : "+ Arrays.toString(strings));
// }
public static void main(String[] args){
MultiIterableClass multiIterableClass = new MultiIterableClass();
multiIterableClass.f();
for(String s : multiIterableClass.revesed()){
printnb(s+" ");
}
print("");
for(String s : multiIterableClass.random(5)){
printnb(s+" ");
}
print("");
//multiIterableClass继承了IterableClass，如果不重写iterator方法，则访问基类的域，重写了iterator则访问该类的域。参考上面的f()。
for(String s : multiIterableClass){
printnb(s+" ");
}
}
}
- 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
- 86
- 87
- 88
- 89
Java中的所有Collection类（除了各种Map）都是Iterable类型。Map可以使用entrySet()和values()方法产生Colletion，使Map可以应用于forech。Map用foreach的例子：
package hodling;//: holding/EnvironmentVariables.java
import java.util.*;
public class EnvironmentVariables {
public static void main(String[] args) {
for(Map.Entry entry: System.getenv().entrySet()) {
System.out.println(entry.getKey() + ": " +
entry.getValue());
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
System.getenv()返回一个Map，entrySet产生一个由Map.Entry（即：key-value pair）元素构成的Set(即：Set <Map.Entry<K, V>> entrySet();)，并且这个Set是一个Iterable，可以用于foreach循环。