JavaSE_day16【泛型与集合】

JavaSE_day16【泛型、集合】

主要内容

• 泛型
• Collection集合

学习目标

• 能够使用泛型定义类、接口、方法
• 能够理解泛型上限
• 能够阐述泛型通配符的作用
• 能够识别通配符的上下限
• 能够熟练使用Collection集合的API
• 能够使用Iterator迭代器遍历Collection系列的集合
• 能够使用foreach遍历Collection系列的集合

第十一章 泛型

11.1 泛型的概念

11.1.1 泛型的引入

例如：生产瓶子的厂家，一开始并不知道我们将来会用瓶子装什么，我们什么都可以装，但是有的时候，我们在使用时，想要限定某个瓶子只能用来装什么，这样我们不会装错，而用的时候也可以放心的使用，无需再三思量。我们生活中是在使用这个瓶子时在瓶子上“贴标签”，这样就轻松解决了问题。

还有，在Java中我们在声明方法时，当在完成方法功能时如果有未知的数据需要参与，这些未知的数据需要在调用方法时才能确定，那么我们把这样的数据通过形参表示。那么在方法体中，用这个形参名来代表那个未知的数据，而调用者在调用时，对应的传入值就可以了。

受以上两点启发，JDK1.5设计了泛型的概念。泛型即为“类型参数”，这个类型参数在声明它的类、接口或方法中，代表未知的通用的类型。例如：

java.lang.Comparable接口和java.util.Comparator接口，是用于对象比较大小的规范接口，这两个接口只是限定了当一个对象大于另一个对象时返回正整数，小于返回负整数，等于返回0。但是并不确定是什么类型的对象比较大小，之前的时候只能用Object类型表示，使用时既麻烦又不安全，因此JDK1.5就给它们增加了泛型。

public interface Comparable<T>{
    int compareTo(T o) ;
}
1
2
3

public interface Comparator<T>{
     int compare(T o1, T o2) ;
}
1
2
3

其中就是类型参数，即泛型。

11.1.2 泛型的好处

那么我们在使用如上面这样的接口时，如果没有泛型或不指定泛型，很麻烦，而且有安全隐患。如果有了泛型并使用泛型，那么既能保证安全，又能简化代码。

JavaBean：圆类型

class Circle{
	private double radius;

	public Circle(double radius) {
		super();
		this.radius = radius;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}

	@Override
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

比较器

import java.util.Comparator;

public class CircleComparator implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		//强制类型转换
		Circle c1 = (Circle) o1;
		Circle c2 = (Circle) o2;
		return Double.compare(c1.getRadius(), c2.getRadius());
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13

测试类

public class TestGeneric {
	public static void main(String[] args) {
		CircleComparator com = new CircleComparator();
		System.out.println(com.compare(new Circle(1), new Circle(2)));
		
		System.out.println(com.compare("圆1", "圆2"));//运行时异常：ClassCastException
	}
}
1
2
3
4
5
6
7
8

使用泛型：

比较器：

class CircleComparator implements Comparator<Circle>{

	@Override
	public int compare(Circle o1, Circle o2) {
		//不再需要强制类型转换，代码更简洁
		return Double.compare(o1.getRadius(), o2.getRadius());
	}
	
}
1
2
3
4
5
6
7
8
9

测试类

import java.util.Comparator;

public class TestGeneric {
	public static void main(String[] args) {
		CircleComparator com = new CircleComparator();
		System.out.println(com.compare(new Circle(1), new Circle(2)));
		
//		System.out.println(com.compare("圆1", "圆2"));//编译错误，因为"圆1", "圆2"不是Circle类型，编译器提前报错，而不是冒着风险在运行时再报错
	}
}
1
2
3
4
5
6
7
8
9
10

其中：是类型变量（Type Variables），Comparator这种就称为参数化类型（Parameterized Types），Comparator 中的 是参数化类型的类型参数。

类比方法的参数，我们可以把，称为类型形参，将 称为类型实参，有助于我们理解泛型。

11.2 参数类型：泛型类与泛型接口

当我们在声明类或接口时，类或接口中定义某个成员时，该成员有些类型是不确定的，而这个类型需要在使用这个类或接口时才可以确定，那么我们可以使用泛型。

11.2.1 声明泛型类与泛型接口

语法格式：

【修饰符】 class 类名<类型变量列表>{
    
}
【修饰符】 interface 接口名<类型变量列表>{
    
}
1
2
3
4
5
6

注意：

• <类型变量列表>：可以是一个或多个类型变量，一般都是使用单个的大写字母表示。例如：、等。
• <类型变量列表>中的类型变量不能用于静态成员上。

示例代码：

例如：我们要声明一个学生类，该学生包含姓名、成绩，而此时学生的成绩类型不确定，为什么呢，因为，语文老师希望成绩是“优秀”、“良好”、“及格”、“不及格”，数学老师希望成绩是89.5, 65.0，英语老师希望成绩是’A’,‘B’,‘C’,‘D’,‘E’。那么我们在设计这个学生类时，就可以使用泛型。

public class Student<T>{
	private String name;
	private T score;
	
	public Student() {
		super();
	}
	public Student(String name, T score) {
		super();
		this.name = name;
		this.score = score;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public T getScore() {
		return score;
	}
	public void setScore(T score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "姓名：" + name + ", 成绩：" + score;
	}
}
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

11.2.2 使用泛型类与泛型接口

在使用这种参数化的类与接口时，我们需要指定泛型变量的实际类型参数：

（1）实际类型参数必须是引用数据类型，不能是基本数据类型

（2）在创建类的对象时指定类型变量对应的实际类型参数

public class TestGeneric{
	public static void main(String[] args) {
		//语文老师使用时：
		Student<String> stu1 = new Student<String>("张三", "良好");
        
		//数学老师使用时：
        //Student stu2 = new Student("张三", 90.5);//错误，必须是引用数据类型
		Student<Double> stu2 = new Student<Double>("张三", 90.5);
        
		//英语老师使用时：
		Student<Character> stu3 = new Student<Character>("张三", 'C');
        
        //错误的指定
        //Student