Java 泛型

引言-idea技巧（快捷键）

itit+Tab 生成iterator 迭代
1

泛型的理解和好处

已经由多态了，为什么还需要泛型？

传统方式

public class Generic01 {
    public static void main(String[] args) {

        //使用传统的方法来解决
        ArrayList arrayList = new ArrayList();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));

        //假如我们的程序员，不小心，添加了一只猫
        // 1) 这里编译不会报错，因为.add(Object o)方法中参数的类型是Object类，可以承接任何子类，所以编译不会报错
        arrayList.add(new Cat("招财猫", 8));

        //遍历
        // 2).1.
        for (Object o : arrayList) {
//            向下转型Object ->Dog
			// 2).2.
            Dog dog = (Dog) o;
            System.out.println(dog.getName() + "-" + dog.getAge());
        }

    }
}
/*
请编写程序，在ArrayList 中，添加3个Dog对象
Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
 */
class Dog {
    private String name;
    private int age;
    public Dog(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;
    }
}

class Cat { //Cat类
    private String name;
    private int age;
    public Cat(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;
    }
}
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

• 使用传统方法的问题分析
  1）不能对加入到集合 ArrayList 中的数据类型进行约束（不安全）
  // 2).1.：这里没办法用 Dog（即子类）对象来接收arrayList中对象的原因是：ArrayList类默认存放Object类，当使用.add()方法向arrayList中添加对象后，会进行向上转型，故此时arrayList中存放的都是Object对象，子类是无法接收父类的，除非进行强制类型转换。
  // 2).1.：尽管程序员自己知道存放的是哪个类（在这里是Dog类），但在语法层面并不通过（只能写“Object o : arrayList”），arrayList要求一个Object引用去承接它，故在代码中还需要进行向下转型
  2）遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响
  // 2).2.：“Dog dog = (Dog) o;”这种写法是存在隐患的，但编译器发现不了

用泛型来解决前面的问题（快速入门）

public class Generic02 {
    public static void main(String[] args) {

        //使用传统的方法来解决===> 使用泛型
        //老韩解读
        //1. 当我们 "ArrayList" 这么表示时， 代表存放到 ArrayList 集合中的元素是Dog类型(或Dog的子类，遵守继承机制) (细节后面说...)
        // Dog并不代表泛型，代表给泛型指定的那一个类型
        //2. 如果编译器发现添加的类型，不满足要求，就会报错，如：arrayList.add(new Cat("招财猫", 8));（相当于加入了一个数据类型约束）
        // 报错信息：'add(com.hspedu.generic.improve.Dog)' in 'java.util.ArrayList' cannot be applied to '(com.hspedu.generic.improve.Cat)'【applied 译为应用】
        //3. 在遍历的时候，可以直接取出 Dog 类型而不是 Object
        //4. public class ArrayList {} E称为泛型,那么 Dog->E(把Dog指定给了E，只要在ArrayList类内出现E，都会用Dog去替代)
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));
        //假如我们的程序员，不小心，添加了一只猫
        //arrayList.add(new Cat("招财猫", 8));
        System.out.println("===使用泛型====");
        // 可以直接取出Dog类型
        for (Dog dog : arrayList) {
            System.out.println(dog.getName() + "-" + dog.getAge());
        }


    }
}

/*
1.请编写程序，在ArrayList 中，添加3个Dog对象
2.Dog对象含有name 和 age, 并输出name 和 age (要求使用getXxx())
3.老师使用泛型来完成代码
 */
class Dog {
    private String name;
    private int age;
    public Dog(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;
    }
}

class Cat { //Cat类
    private String name;
    private int age;
    public Cat(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;
    }
}
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

泛型的好处

（1）编译时，检查添加元素的类型，提高了安全性

（2）减少了类型转换的次数，提高效率

（3）编译警告->可以提示程序员放入的类型是否正确，就不会在运行后才发现错误了

泛型基本语法

泛型介绍

类比理解：
    int a可以赋值2，4，7等等（即任意一个整数）；那么类比 变量a，我们有一个泛型E，它可以赋Integer，String，自定义类等等（即任意一个数据类型）。

也就是说，通俗理解来说，泛型就是说可以给它指定一种数据类型，至于指定哪一种数据类型是由程序员来决定的（泛型也可以认为是可以表示数据类型的一种数据类型）

泛（广泛）型（类型） => Integer，String，Dog
（1）泛型又称参数化类型（像形参一样，需要给它传值），是Jdk5.0 出现的新特性，解决数据类型的安全性问题（在编译时就可以显示出来，就不会带着这个错误去运行）
（2）在类声明或实例化时只要指定好需要的具体的类型即可
（3）Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生 ClassCastException 异常。同时，代码更加简洁、健壮
（4）泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。[ 如下面示例代码所示 ]

示例代码

public class Generic03 {
    public static void main(String[] args) {

        //注意，特别强调： E具体的数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型
        Person<String> person = new Person<String>("韩顺平教育");
        person.show(); //String

        /*
            你可以这样理解，上面的Person类
            class Person {
                String s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型

                public Person(String s) {//E也可以是参数类型
                    this.s = s;
                }

                public String f() {//返回类型使用E
                    return s;
                }
            }
         */

        Person<Integer> person2 = new Person<Integer>(100);
        person2.show();//Integer

        /*
            class Person {
                Integer s ;//E表示 s的数据类型, 该数据类型在定义Person对象的时候指定,即在编译期间，就确定E是什么类型

                public Person(Integer s) {//E也可以是参数类型
                    this.s = s;
                }

                public Integer f() {//返回类型使用E
                    return s;
                }
            }
         */
    }
}

//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型

class Person<E> {
    E s ;//E表示 s的数据类型, 该数据类型是在定义Person对象的时候指定的,即在编译期间，就确定E是什么类型

    public Person(E s) {//E也可以是参数类型
        this.s = s;
    }

    public E f() {//返回类型使用E
        return s;
    }

    public void show() {
        System.out.println(s.getClass());//显示s的运行类型
        // 若想查看为泛型指定的类型具体是什么类型的，可以使用.getClass()方法
    }
}
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

泛型的声明

interface 接口 {} 和 class 类{}
// 比如：List【接口】，ArrayList【类】
说明：
1）其中，T，K，V不代表值，而是表示类型
2）任意字母都可以。常用T表示，是Type的缩写

泛型的实例化（什么时候给泛型指定一个具体的类型）—— 一般来说是创建一个对象的时候指定的

要在类名后面指定类型参数的值（类型）。如：
1）List strList = new ArrayList();
2）Iterator iterator = customers.iterator();

示例代码

public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式给HashSet 放入3个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));

        //遍历
        for (Student student : students) {
            System.out.println(student);
        }

        //使用泛型方式给HashMap 放入3个学生对象
        //K -> String V->Student
        HashMap<String, Student> hm = new HashMap<String, Student>();
        /* 
            public class HashMap  {}
         */
        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
        hm.put("hsp", new Student("hsp", 28));

        //迭代器 EntrySet
        /*
        public Set> entrySet() {
            Set> es;
            return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
        }
         */
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        /*
            public final Iterator> iterator() {
                return new EntryIterator();
            }
         */
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        // iterator 指向的是 "" 这种元素
        System.out.println("==============================");
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            // 由于 next 是个 Entry，所以可以调用它相关的方法，如K getKey();V getValue();等（Entry是Map中的内部接口，里面的方法都是抽象方法，而）
            System.out.println(next.getKey() + "-" + next.getValue());
            
        }

    }
}
/**
 * 创建  3个学生对象
 * 放入到HashSet中学生对象, 使用.
 * 放入到  HashMap中，要求 Key 是 String name, Value 就是 学生对象
 * 使用两种方式遍历
 */
class Student {
    private String name;
    private int age;

    public Student(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 "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
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

知识点（ 对应代码将3个学生对象放入HashMap中，并使用Iterator(迭代器)进行迭代 ）

首先由这张图我们可以知道 Collection 接口和 Map 接口没有关系,是相互独立的,但是都属于集合类的一部分。而 Set 接口是继承自 Collection 接口的子接口，且所用的 Collection 类都支持一个 iterator()方法（来自Iterable接口【 ① Iterable Iterable是java集合接口的顶级接口之一，这个接口中内含iterator()方法，用来返回一个实现了 Iterable 接口的对象；② Iterator(迭代器)提供了一种简单、高效的遍历方法,并且可以在遍历的过程中对集合或者数组进行增、删、改操作。】） 来遍历。理解了它们几个之间的关系之后，我们再来看一下下面这段代码。
/**
Set> entries = hm.entrySet(); // (1)
Iterator> iterator = entries.iterator(); // (2)
System.out.println(“==============================”);
while (iterator.hasNext()) { // (3)
   Map.Entry next = iterator.next();
   System.out.println(next.getKey() + “-” + next.getValue());
}
*/
(1) 中使用 HashMap 类中的方法 .entrySet() 将HashMap类型的数据转换成集合类型（以便使用迭代器去迭代），.entrySet()方法源码如下：
(1).1 方法 .entrySet() 中包含的字段 entrySet 是 HashMap 类中定义的属性，源码如下：
翻译：保留缓存的entrySet（）。请注意，AbstractMap字段用于keySet（）和values（）。
其中关键字 transient 的作用是： 一旦类的某个成员变量被 transient 修饰,该变量将不再是对象持久化的一部分,即无法被序列化和反序列化。
(1).2 方法 .entrySet() 中返回的是 HashMap 内部类对象，其中包含 iterator() 方法可以返回一个迭代器（ 注释(2) ），这样我们就可以使用迭代器来遍历集合中的元素了（ 注释(3) ）。
还需要注意的是，在上述代码中，编译器能直接知道给凉饿泛型指定的分别是 String 和 Student 的原因是在创建HashMap对象时接收 String 和Student 的泛型K和泛型V与这里源码中所有的K和V都是对应的，故编译器 在接收到创建时传入的两个类型后，就知道了接下来上下的相关操作也要传入什么类型了。（总的来说，其根本原因就是因为在定义 HashMap 时，已经把它的K和V都指定了）源码如下：
首先我们可以看到类头中包含：
其次包含集合类型的属性 entrySet 中也有：
相关问题：HashMap 底层的成员变量 entryset 什么时候被赋值？
答：第一次调用 entrySet 的时候，会被初始化
entrySet() 方法及 HashMap 内部类 EntrySet

泛型语法和使用

1. interface 接口 {}，class 类 {}…等等
   说明：T, E只能是引用类型
2. 在给泛型指定具体类型后，可以传入该类型或者其子类类型（即在泛型类内，只要是用泛型表示的数据类型的地方也可以用指定的引用类型的子类的类型来代替）
3. 泛型使用形式
   List list1 = new ArrayList();
   List list2 = new ArrayList<>();
   // 在实际开发中，往往使用简写，推荐这种简写的写法；编译器会进行类型推断，将等号左边的类型自动填充到等号右边。需要注意的是，等号右边的类型可省略，但等号左边的类型是不可以省略的，省略后会报错
   如果我们这样写： List list3 = new ArrayList(); 默认它的泛型是【 E就是Object】

示例代码：

public class GenericDetail {
    public static void main(String[] args) {
        //1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>(); //OK
        //List list2 = new ArrayList();//错误

        //2. 说明
        //因为 E 指定了 A 类型, 构造器传入了 new A()
        //在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();

        //3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        //在实际开发中，我们往往简写
        //编译器会进行类型推断, 老师推荐使用下面写法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();

        //4. 如果是这样写 泛型默认是 Object
        ArrayList arrayList = new ArrayList();//等价 ArrayList