集合迭代器 Iterator Iterable iterator_为实现“iterable”中的抽象方法

集合迭代器

迭代器的设计理念

不同的集合有不同的遍历的方法,这在使用中是极其不方便的,那么能不能使用同一种遍历的方法,遍历所有集合,即用一个类中的若干方法可以操作不同集合中的各种数据.那么不同的集合他的实现方式不同,存储数据的结构也不同,要想实现使用一种方法来操作不同的集合数据,可以使用一个新的对象,在这个对象中包含了操作不同集合的统一的方法,方法可以是同一个方法,但是方法的具体实现可以时不同的实现过程,可以在不同的集合中给出不同具体实现,以达到使用同一个方法,操作不同的集合的目的

若干名词

• Iterator :是一个接口,在这个接口中规定了迭代器的操作方法,和操作规范
• Iterable:是一个接口,在这个接口中规定了,集合的iterator方法的实现规范,以及返回类型
• iterator:是一个方法,在各集合类中给出了具体实现,这个方法的返回值是Iterator类类型,即返回一个当前集合的迭代器

各类之间的关系

1. Iteator 接口是迭代器接口,这个接口迭代器的接口,规定了迭代器的方法,由实现这个接口的具体类给出方法体
2. Iterable 是一个接口,这个接口是集合接口Collection的父接口,即Collection接口继承了Iterable接口,所以Collection的实现类需要给出Iterable接口内抽象方法的具体实现
3. iterator 是集合类的具体方法,这个方法,会返回一个Iterator类类型的对象 即返回一个迭代器对象,用这个对象可以打点调用Iterator中的方法,其具体的执行过程是子类给出的具体实现,即返回一个长辈类类型的对象,用长辈类的对象打点调方法,调用的是子类自己的方法,多态的应用
4. 要实现多态,必须要有继承,重写,在迭代器的具体实现中,具体的集合类,实现了 Iterator和Iterable中规定的方法,iterator是接口Iterable中规定的方法,这个方法返回一个Iterator类类型的对象,然后Iterator是一个接口,接口中的方法没有方法体,所以这个Iterator类类型的对象打点调用的是子类给出的具体实现

Iterator Iterable iterator的联系和区别

1. Iterator是一个接口,Iterable是一个接口,iterator是方法
2. Iterable中规定了一个返回类型为Iterator类类型的方法
3. 集合的顶级接口Collection继承了Iterable接口,即Collection的子类需要给出Iterable中抽象方法的具体实现
4. 在Collection子类中一定给出的Iterator接口中方法的具体实现,这样就可以用多态的原理,用一个Iterator对象去操作不同的集合

不同的集合中使用迭代器的具体代码

• List集合
• List集合继承自Collection接口,在List中规定了List集合的操作规范和实现步骤
• ArrayList 集合,继承了 Collection接口,在此类中给出了父类中抽象方法的具体实现
• LikedList集合,继承了 Collection接口,在此类中有操作此类的具体方法

自己新建一个类,作为集合中数据的类型

public class Programmer {
	private String name;//程序员的名字
	private int age;//程序员的年龄
	private int salary;//程序员的工资
	public Programmer(){}//无参构造
	//有参构造
	public Programmer(String name, int age, int salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	//getter  setter方法
	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;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
	//重写一个toString方法,用于检测迭代器
	@Override
	public String toString() {
		return "Programmer [name=" + name + ", age=" + age + ", salary=" + salary + "]";
	}
	
}

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

ArrayList迭代器的举例

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

public class ArrayListIterator {
	public static void main(String[] args) {
		// 新建一个集合对象
		ArrayList<Programmer> programmer = new ArrayList<Programmer>();
		//创建集合中元素的对象
		Programmer p1 = new Programmer("张三",22,8000);
		Programmer p2 = new Programmer("李四",21,9000);
		Programmer p3 = new Programmer("王五",22,10000);
		Programmer p4 = new Programmer("赵六",23,11000);
		Programmer p5 = new Programmer("田七",24,12000);
		//给集合添加对象
		programmer.add(p1);
		programmer.add(p2);
		programmer.add(p3);
		programmer.add(p4);
		programmer.add(p5);
		//获取集合的迭代器
		Iterator<Programmer> arraylistiterator = programmer.iterator();
		//使用集合的迭代器操作集合的数据
		while(arraylistiterator.hasNext()){//判断迭代器中是否还有元素
			Programmer p = arraylistiterator.next();//取出一个元素
			System.out.println(p.toString());//打印元素的内容
		}
	}
}
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

运行结果

Programmer [name=张三, age=22, salary=8000]
Programmer [name=李四, age=21, salary=9000]
Programmer [name=王五, age=22, salary=10000]
Programmer [name=赵六, age=23, salary=11000]
Programmer [name=田七, age=24, salary=12000]

HashSet迭代器举例

public class HashSetIterator {

	public static void main(String[] args) {
		// 新建一个集合对象
		HashSet<Programmer> programmer = new HashSet<Programmer>();
		// 创建集合中元素的对象
		Programmer p1 = new Programmer("张三", 22, 8000);
		Programmer p2 = new Programmer("李四", 21, 9000);
		Programmer p3 = new Programmer("王五", 22, 10000);
		Programmer p4 = new Programmer("赵六", 23, 11000);
		Programmer p5 = new Programmer("田七", 24, 12000);
		// 给集合添加对象
		programmer.add(p1);
		programmer.add(p2);
		programmer.add(p3);
		programmer.add(p4);
		programmer.add(p5);
		// 获取集合的迭代器
		Iterator<Programmer> programmeriterator = programmer.iterator();
		while(programmeriterator.hasNext()){
			Programmer p =  programmeriterator.next();
			System.out.println(p.toString());
		}

	}


}
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

运行结果

Programmer [name=张三, age=22, salary=8000]
Programmer [name=李四, age=21, salary=9000]
Programmer [name=王五, age=22, salary=10000]
Programmer [name=赵六, age=23, salary=11000]
Programmer [name=田七, age=24, salary=12000]

HashMap集合举例

public class HashMapIterator {
	public static void main(String[] args) {
		// 新建一个集合对象
		HashMap<String,Programmer> programmer = new HashMap<String,Programmer>();
		// 创建集合中元素的对象
		Programmer p1 = new Programmer("张三", 22, 8000);
		Programmer p2 = new Programmer("李四", 21, 9000);
		Programmer p3 = new Programmer("王五", 22, 10000);
		Programmer p4 = new Programmer("赵六", 23, 11000);
		Programmer p5 = new Programmer("田七", 24, 12000);
		//给集合中添加对象
		programmer.put(p1.getName(), p1);
		programmer.put(p2.getName(), p2);
		programmer.put(p3.getName(), p3);
		programmer.put(p4.getName(), p4);
		programmer.put(p5.getName(), p5);
		//获取键的迭代器
		Set<String> keys = programmer.keySet();
		Iterator<String> keysiterator = keys.iterator();
		while(keysiterator.hasNext()){
			String str =keysiterator.next();
			System.out.println(str);
		}
		System.out.println("------------------------------------------");
		//获取值的迭代器
		Collection<Programmer> values = programmer.values();
		Iterator<Programmer> valuesiterator = values.iterator();
		while(valuesiterator.hasNext()){
			Programmer p = valuesiterator.next();
			System.out.println(p.toString());
		}
	}
}

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

运行结果

李四
张三
王五
赵六
田七

---

Programmer [name=李四, age=21, salary=9000]
Programmer [name=张三, age=22, salary=8000]
Programmer [name=王五, age=22, salary=10000]
Programmer [name=赵六, age=23, salary=11000]
Programmer [name=田七, age=24, salary=12000]