学习java笔记 --- 一个实现Iterable<E>接口的小范例

以下的文档摘自JDK 5.0文档说明

java.lang

接口 Iterable<T>

public interface Iterable<T>

实现这个接口允许对象成为 "foreach" 语句的目标。

方法摘要
Iterator<T>	iterator() 返回一个在一组 T 类型的元素上进行迭代的迭代器。

方法详细信息

iterator

Iterator<T> iterator()

返回一个在一组 T 类型的元素上进行迭代的迭代器。

返回：

一个迭代器。

=============================================

以下的文字不是摘自JDK 5.0文档

其中上面有说明了，实现这个接口允许对象成为 "foreach" 语句的目标。这样就可以类似使用数组那样，用foreach语句来遍历所有相关的对象了

像这样的用法：

		String[] s ={"a","b","c"};
		for (String ss : s) {
			System.out.println("ss: "+ss);
		}

Iterable<T>
不过，像一般自定义的类和其实例对象，想要使用for each语句来遍历它本身集体的话，可能就要实现Iterable<T>接口了。

像以下的代码：

（code1）

package cn.yang.collection;

import java.util.Iterator;

/**
 * 实现Iterable<E>接口的Person类
 * @author yangqinjiang
 *
 */
public class Person implements Iterable<Person>{


	/**
	 * 实现Iterable接口中要求实现的方法
	 */
	@Override
	public Iterator<Person> iterator() {
		return new MyIterator();//返回一个MyIterator实例对象
	}
	
	/**
	 * MyIterator是内部类，实现了Iterator<E>接口的类
	 * 像这样的内部类，在网络上有很多这样的写法，我这里只是参考他们的写法罢了
	 * @author yangqinjiang
	 *
	 */
	class MyIterator implements Iterator<Person>{

		/**相当于索引*/
		private int index =0;
		@Override
		public boolean hasNext() {
			//只要在调用next()后，index自加，确保index不等于person的长度
			return index!=person.length;
		}

		@Override
		public Person next() {
			//使用索引来获取person数组中的某一项
			return person[index++];
		}

		@Override
		public void remove() {
			//未实现这个方法
		}
		
	}

	
	private String name;
	private int age;
	/**person数组，是目标操作对象*/
	private Person[] person;
	
	/**为了方便简单点，故写一个这样的构造方法*/
	public Person(int size){
		person=new Person[size];
		for (int i = 0; i < size; i++) {
			person[i]=new Person(""+i, i);
		}
	}
	
	public void add(Person person){
		//未实现这个方法
	}
	
	public Person(){
		//未实现这个方法
	}
	
	public Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	
	//getter
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "person [name=" + name + ", age=" + age + "]";
	}

	
}

（code2）

package cn.yang.collection;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 实现Iterable<E>接口的Person2类
 * @author yangqinjiang
 *
 */
public class Person2 implements Iterable<Person2>{


	/**
	 * 实现Iterable接口中要求实现的方法
	 */
	@Override
	public Iterator<Person2> iterator() {
		return new MyIterator();//返回一个MyIterator实例对象
	}
	
	/**
	 * MyIterator是内部类，实现了Iterator<E>接口的类
	 * 像这样的内部类，在网络上有很多这样的写法，我这里只是参考他们的写法罢了
	 * @author yangqinjiang
	 *
	 */
	class MyIterator implements Iterator<Person2>{
		/**相当于索引,不过不是数组索引*/
		private int index =0;
		@Override
		public boolean hasNext() {
			return index!=person.size();
		}

		@Override
		public Person2 next() {
			return person.get(index++);
		}

		@Override
		public void remove() {
			
		}
		
	}

	
	private String name;
	private int age;
	/**在Person2类中，person是一个数组链表*/
	private List<Person2> person=new ArrayList<Person2>();
	
	/**添加一个新Person2实例对象到person链表中*/
	public void add(Person2 person2){
		this.person.add(person2);
	}
	
	public Person2(){
		
	}
	
	public Person2(String name,int age){
		this.name=name;
		this.age=age;
		
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "person [name=" + name + ", age=" + age + "]";
	}

	
}

然后在main方法中，一个一个地调用下面方法

(code3)

	/**
	 * 使用"for each" 循环,可以打印数组
	 */
	private static void printStrings() {
		System.out.println("printStrings() method running");
		String[] s ={"d","f","s"};
		for (String ss : s) {
			System.out.println("ss: "+ss);
		}
		System.out.println("printStrings() method end\n");
	}

输出结果:

printStrings() method running
ss: d
ss: f
ss: s
printStrings() method end

(code4)

System.out.println("testPerson() method running");
		
		Person y1=new Person("1", 1);
		Person y2=new Person("2", 2);
		Person y3=new Person("3", 3);
		Person y4=new Person("4", 4);
		Person y5=new Person("5", 5);
		//数组
		Person y[]={y1,y2,y3,y4,y5};
		for (Person ys : y) {
			System.out.println(ys.getName());
		}

		//Iterator
		System.out.println("Iterator<Person>...");
		Iterator<Person> i = new Person(10).iterator();
		while(i.hasNext()){
			System.out.println(i.next().toString());
		}
		
		//也可以这样打印
		System.out.println("other...");
		Person yy=new Person(20);
		
		for (Person ys : yy) {
			System.out.println(ys.toString());
		}
		System.out.println("testPerson() method end\n");

输出结果:

testPerson() method running
1
2
3
4
5
Iterator<Person>...
person [name=0, age=0]
...
person [name=9, age=9]
other...
person [name=0, age=0]
...
person [name=19, age=19]
testPerson() method end

(code5)

System.out.println("testPerson2() method running");
		
		Person2 p = new Person2("300", 300);
		Person2 p1 = new Person2("30", 30);
		Person2 p2 = new Person2("40", 40);
		Person2 p3 = new Person2("50", 50);
		Person2 p4 = new Person2("60", 60);
		Person2 p5 = new Person2("70", 70);
		p.add(p1);
		p.add(p2);
		p.add(p3);
		p.add(p4);
		p.add(p5);
		//Iterator
		Iterator<Person2> ii=p.iterator();
		while (ii.hasNext()) {
			System.out.println("Person2:  "+ii.next().toString());
		}
		System.out.println("testPerson2() method end\n");

输出结果:

testPerson2() method running
Person2:  person [name=30, age=30]
Person2:  person [name=40, age=40]
Person2:  person [name=50, age=50]
Person2:  person [name=60, age=60]
Person2:  person [name=70, age=70]
testPerson2() method end

总结：很明显，实现这个接口允许对象成为 "foreach" 语句的目标。（呵呵，拿这句话来当成总结吧）

20120504,五四青年节哟，为何学校不放假？呀，五一才过了不久，又想着放五四节了》》其实在大学里，可以把每天当成周末的啦。光阴似箭啊，珍惜