Java中Iterable和Iterator区别与联系

        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);
        }
    }
}

        为什么要在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+" ");
        }
    }
}

        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());
    }
  }
}

System.getenv()返回一个Map，entrySet产生一个由Map.Entry（即：key-value pair）元素构成的Set(即：Set <Map.Entry<K, V>> entrySet();)，并且这个Set是一个Iterable，可以用于foreach循环。