2022.4.25 集合 泛型（Generic）

泛型

概念：

Java泛型（generics）是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。泛型的本质就是参数化类型（将类型参数化），也就是所操作的数据类型被指定为一个参数。

类型：

• E - Element (在集合中使用，因为集合中存放的是元素)

• T - Type（表示Java 类，包括基本的类和我们自定义的类）

• K - Key（表示键，比如Map中的key）

• V - Value（表示值）

• N - Number（表示数值类型）

• ？ - （表示不确定的java类型）

• S、U、V - 2nd、3rd、4th types

泛型类

泛型类定义语法

class 类名称 <泛型标识,泛型标识...>{//可以作为成员变量、方法参数、方法返回值的类型
    private 泛型标识 变量名;
    ......
}

Generic

package com.xing.generic;
​
/*
    泛型类的定义
    泛型标识相当于类型参数
    T 在创建Generic类的对象时,需指定具体的参数类型
 */
public class Generic<T> {
    private T key;
    // 泛型  不能实例化   T t = new T();  因为不知T的具体类型
​
    public Generic() {
    }
​
    public Generic(T key) {
        this.key = key;
    }
​
    public T getKey() {
        return key;
    }
​
    public void setKey(T key) {
        this.key = key;
    }
​
    @Override
    public String toString() {
        return "Generic{" +
                "key=" + key +
                '}';
    }
}

泛型类的使用

泛型类，是在实例化类的时候指明泛型的具体类型。

类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

注：Java1.7以后，后面的<>中的具体的数据类型可以省略不写

类名<具体的数据类型> 对象名 = new 类名<>(); 称为菱形语法

泛型类注意事项

• 泛型类在创建对象的时候，如果没有指定具体的数据类型，此时，操作类型是Object

• 泛型的类型参数只能是类类型，不能是基本数据类型（int等）

• 泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同类型

• 泛型类中不能定义静态方法，除非是泛型方法（如果static方法要使用泛型能力，就必须使其成为泛型方法）

Generic

package com.xing.generic;
​
/*
    泛型类的定义
    泛型标识相当于类型参数
    T 在创建Generic类的对象时,需指定具体的参数类型
 */
public class Generic<T> {
    private T key;
​
    public Generic() {
    }
​
    public Generic(T key) {
        this.key = key;
    }
​
    public T getKey() {
        return key;
    }
​
    // 报错  泛型类中不能定义静态方法,除非是泛型方法
    // public static T get1() {
    //     return "报错";
    // }
​
    //如果static方法要使用泛型能力，就必须使其成为泛型方法
    //不会受泛型类的泛型标识影响   泛型方法的泛型标识与泛型类的泛型标识无关  
    //<T,E,V> 说明这个方法是范型方法而已    返回值与参数的泛型标识必须在泛型列表<T,E,V>中
    public static <T,E,V> T get(T t) {
        return t;
    }
​
    public void setKey(T key) {
        this.key = key;
    }
​
    @Override
    public String toString() {
        return "Generic{" +
                "key=" + key +
                '}';
    }
}

GenericTest

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
        //泛型类在创建对象的时候来指定操作的具体数据类型 必须是引用类型
​
        // 使用的空参构造
        Generic<String> stringGeneric = new Generic<>();
​
        // 使用的带参构造   我们指定泛型为String类型,所以参数只能是String类型
        Generic<String> stringGeneric1 = new Generic<>("小明");
        String key = stringGeneric1.getKey();
        System.out.println(key);//小明
​
        // 使用的带参构造   我们指定泛型为Integer类型,所以参数只能是Integer类型
        Generic<Integer> integerGeneric = new Generic<>(100);
        Integer key1 = integerGeneric.getKey();
        System.out.println(key1);//100
​
​
        // 泛型类在创建对象的时候，如果没有指定具体的数据类型，此时，操作类型是Object
        Generic generic = new Generic("abc");
        Object key2 = generic.getKey();
        System.out.println(key2);//abc
​
​
        // 泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同类型
        System.out.println(stringGeneric.getClass());//class com.xing.generic.Generic
        System.out.println(integerGeneric.getClass());//class com.xing.generic.Generic
        //可以结合后面的泛型擦除理解，泛型擦除之后 Generic < String > 和Generic< Integer >都是Generic类
        System.out.println(stringGeneric.getClass()==integerGeneric.getClass());//true
​
    }
​
}

测试

Box

package com.xing.generic;
​
import java.util.ArrayList;
import java.util.Random;
//泛型可以写多个   泛型列表
public class Box<T,E> {
​
    Random random = new Random();
​
    // 存放物品
    ArrayList<T> arrayList = new ArrayList<>();
    ArrayList<E> list = new ArrayList<>();
​
    // 向集合中添加物品
    public void put(T t) {
        arrayList.add(t);
    }
​
    // 随机拿取集合中的物品
    public T get() {
        // nextInt()方法的参数是一个限定范围,随机数的范围不超过arrayList.size()
        T t = arrayList.get(random.nextInt(arrayList.size()));
        return t;
    }
​
    public void put1(E e) {
        list.add(e);
    }
​
    // 随机拿取集合中的物品
    public E get1() {
        // nextInt()方法的参数是一个限定范围,随机数的范围不超过arrayList.size()
        E e = list.get(random.nextInt(list.size()));
        return e;
    }
​
    public void print(T t, E e) {
​
        System.out.println(t.toString()+e.toString());
    }
​
}

GenericTest

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
​
        Box<String, Integer> stringIntegerBox = new Box<>();
​
        String[] goods = {"手机","耳机","洗衣液"};
        for (String good : goods) {
            stringIntegerBox.put(good);
        }
        System.out.println(stringIntegerBox.get());
​
        Integer[] money = {100, 1000, 50};
        for (Integer integer : money) {
            stringIntegerBox.put1(integer);
        }
        System.out.println(stringIntegerBox.get1());
​
​
        stringIntegerBox.print("小明多大了?   ",20);//小明多大了?   20
​
    }
​
}

从泛型类派生子类

子类也是泛型类，子类和父类的泛型类型要一致

Parent

package com.xing.generic;
​
// 父类
public class Parent<E> {
    private E value;
    public E getValue() {
        return value;
    }
    public void setValue(E value) {
        this.value = value;
    }
}

ChildFirst

package com.xing.generic;
​
// 泛型类派生子类，子类也是泛型类，那么子类的泛型标识要含有父类的泛型标识。
public class ChildFirst<T,V> extends Parent<T> {
    @Override
    public T getValue() {
        return super.getValue();
    }
}

GenericTest

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
​
        //创建子类对象时 会先去创建父类对象  将子类泛型标识传递给父类  父类的泛型类型就会定义为其类型
        ChildFirst<String, Integer> stringIntegerChildFirst = new ChildFirst<>();
​
        stringIntegerChildFirst.setValue("abc");
        System.out.println(stringIntegerChildFirst.getValue());//abc
​
    }
​
}

子类不是泛型类，父类要明确泛型的数据类型

Parent

package com.xing.generic;
​
// 父类
public class Parent<E> {
    private E value;
    public E getValue() {
        return value;
    }
    public void setValue(E value) {
        this.value = value;
    }
}

ChildFirst 就相当于一个普通的类了

package com.xing.generic;
​
// 泛型类派生子类，如果子类不是泛型类，那么父类要明确数据类型
public class ChildFirst extends Parent<Integer> {
    @Override
    public Integer getValue() {
        return super.getValue();
    }
    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }
}

泛型接口

泛型接口的定义语法

//泛型接口  不能创建范型静态常量   常量在创建时必须初始化  定义范型时只能是定义
//接口可以包含抽象方法  静态常量
interface 接口名称 <泛型标识，泛型标识，…> {
    //默认 public static final
    String name = "张三";
    泛型标识 方法名(); 
    .....
}

泛型接口的使用

实现类也是泛型类，实现类和接口的泛型类型要一致

Generator

package com.xing.generic;
​
//泛型接口  不能创建范型静态常量   常量在创建时必须初始化  定义范型时只能是定义
//接口可以包含抽象方法  静态常量
public interface Generator<T> {
    T getKey();
}

Pair

package com.xing.generic;
​
/**
 * 泛型接口的实现类，是一个泛型类，
 * 那么要保证实现接口的泛型类泛型标识包含泛型接口的泛型标识
 * @param <T>
 * @param <E>
 */
public class Pair<T,E> implements Generator<T> {
​
    private T key;
    private E value;
​
    public Pair(T key, E value) {
        this.key = key;
        this.value = value;
    }
​
    @Override
    public T getKey() {
        return key;
    }
​
    public E getValue() {
        return value;
    }
}

GenericTest

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
        Pair<String, Integer> stringIntegerPair = new Pair<String, Integer>("小明",100);
​
        String key = stringIntegerPair.getKey();
        System.out.println(key);//小明
        Integer value = stringIntegerPair.getValue();
        System.out.println(value);//100
​
    }
​
}

实现类不是泛型类，接口要明确数据类型

Generator

package com.xing.generic;
​
​
//泛型接口
public interface Generator<T> {
    T getKey();
}

Apple

package com.xing.generic;
​
//实现泛型接口的类，不是泛型类，需要明确实现泛型接口的数据类型。
public class Apple implements Generator<String> {
    @Override
    public String getKey() {
        return "hello generic";
    }
}

GenericTest

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
​
        //实现类就是一个普通的类
        Apple apple = new Apple();
        System.out.println(apple.getKey());//hello generic
    }
​
}

泛型方法

泛型方法的定义语法

修饰符 <T，E, ...> 返回值类型 方法名(形参列表) { 
    方法体... 
}

泛型方法的使用

泛型方法是在调用方法的时候指明泛型的具体类型。

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
        GenericTest genericTest = new GenericTest();
        //泛型方法是在调用方法的时候指明泛型的具体类型
        String name = genericTest.get("小明");//根据自己传入的类型 确定范型方法的类型  方法为String类型
        System.out.println(name);
        Integer age = genericTest.get(20);//方法为Integer
        System.out.println(age);
​
        printType("s",100,true);//根据自己传入的类型 确定范型方法的类型 String  Integer  Boolean
​
    }
​
​
    //<T,E,V> 说明这个方法是范型方法而已    返回值与参数的泛型标识必须在泛型列表<T,E,V>中
    //不会受泛型类的泛型标识影响
    public <T,E,V> T get(T t) {
        return t;
    }
​
​
    //静态的泛型方法，采用多个泛型类型
    public static <T,E,K> void printType(T t, E e, K k) {
        System.out.println(t + "\t" + t.getClass().getSimpleName());
        System.out.println(e + "\t" + e.getClass().getSimpleName());
        System.out.println(k + "\t" + k.getClass().getSimpleName());
    }
​
​
}

泛型方法注意事项

• public与返回值中间< T >非常重要，可以理解为声明此方法为泛型方法。

• 只有声明了< T >的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。

• < T >表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。

• 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

• 泛型方法能使方法独立于泛型类而产生变化

• 如果static方法要使用泛型能力，就必须使其成为泛型方法

泛型方法与可变参数

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
​
        print(1, 2, 3);//1 2 3
        print("小明", 2);// 小明 2
        print(true);//true
    }
​
​
    public static <E> void print(E... e){
        for (E e1 : e) {
            System.out.println(e1);
        }
    }
}

类型通配符

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        integerBox.setGoods(100);
        print(integerBox);
​
​
        
        Box<Double> doubleBox = new Box<>();
        doubleBox.setGoods(100.2);
        // 报错  这个方法不能使用其它类型  只能使用Integer
        // print(doubleBox);
    }
​
​
    //这个方法的参数只能传递Box<Integer>类型  不能传Box其它的类型 就算是其子类也不行  必须是Integer
    public static void print(Box<Integer> integerBox){
        Integer goods = integerBox.getGoods();
        System.out.println(goods);
    }
​
​
    //泛型类型在逻辑上可以看成是多个不同的类型，但实际上都是相同类型  com.xing.generic.Generic
    // 这样重载会报错
    // public static void print(Box<Double> doubleBox){
    //     Double goods = doubleBox.getGoods();
    //     System.out.println(goods);
    // }
}

 

为了解决方法只能传入一种类型的泛型，重载会报上述错误，不能解决问题，所以我们使用类型通配符

什么是类型通配符

• 类型通配符一般是使用"?"代替具体的类型实参。

• 类型通配符是类型实参，而不是类型形参。

package com.xing.generic;
​
​
public class GenericTest {
​
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<>();
        integerBox.setGoods(100);
        print(integerBox);
​
​
        Box<String> stringBox = new Box<>();
        stringBox.setGoods("小明");
        print(stringBox);
    }
​
​
    public static void print(Box<?> box){
        Object goods = box.getGoods();
        System.out.println(goods);
    }
​
}

类型通配符的上限

语法：

类/接口<? extends 实参类型>

要求该泛型的类型，只能是实参类型，或实参类型的子类类型。

注意 ：

• 类型通配符上限的list是不能够填充元素的 采用上限不知道list中存放的是什么类型的数据

• 遍历时写最高类型

package com.xing.generic;
​
public class GenericTest {
​
    public static void main(String[] args) {
        Box<Number> numberBox = new Box<>();
        numberBox.setGoods(100);
        //参数为Box<Number>
        print(numberBox);
​
​
        // Integer 继承自 Number类型
        Box<Integer> integerBox = new Box<>();
        integerBox.setGoods(100);
        //参数为Box<Integer>
        print(integerBox);
    }
​
​
    //类型通配符上限到Number类型 
    //类型通配最大类型到Number类型  (这个方法的参数只能传Box泛型标识Number类型及其子类)
    public static void print(Box<? extends Number> box){
        Object goods = box.getGoods();
        System.out.println(goods);
    }
}

测试

Person

package com.xing.generic;
​
public class Person {
}

Father

package com.xing.generic;
​
public class Father extends Person{
}

Son

package com.xing.generic;
​
public class Son extends Father{
}

GenericTest

package com.xing.generic;
​
import java.util.ArrayList;
​
public class GenericTest {
​
    public static void main(String[] args) {
        ArrayList<Person> person = new ArrayList<>();
        ArrayList<Father> father = new ArrayList<>();
        ArrayList<Son> son = new ArrayList<>();
        // print(person);  //报错 print方法最大类型只能到Father类型
        print(father);
        print(son);
​
    }
​
    //类型通配最大类型到Number类型  (之能传Number类型及其子类)
    public static void print(ArrayList<? extends Father> list){
        // 注意 类型通配符上限的list是不能够填充元素的   采用上限不知道list中存放的是什么类型的数据
        // list.add(new Father());报错
​
        //遍历时写最高类型
        //遍历的类型为Father  因为最高类型为Father  其子类型Father也“兼容”
        for (Father father : list) {
            System.out.println(father);
        }
    }
​
}

类型通配符的下限

语法：

类/接口<? super 实参类型>

要求该泛型的类型，只能是实参类型，或实参类型的父类类型。

注意：

• 遍历时写最高类型

• 类型通配符下限的list是能够填充元素的,只能填充低类型及其子类的元素 因为低类型可以被高类型“兼容”

测试

Person

package com.xing.generic;
​
public class Person {
}

Father

package com.xing.generic;
​
public class Father extends Person{
}

Son

package com.xing.generic;
​
public class Son extends Father{
}

GenericTest

package com.xing.generic;
​
​
import java.util.ArrayList;
​
public class GenericTest {
​
    public static void main(String[] args) {
        ArrayList<Person> person = new ArrayList<>();
        ArrayList<Father> father = new ArrayList<>();
        ArrayList<Son> son = new ArrayList<>();
        print(person);
        print(father);
​
        // print(son);//报错 print方法最低类型只能到Father类型
        
    }
​
    public static void print(ArrayList<? super Father> list){
        // 注意 类型通配符下限的list是能够填充元素的,只能填充低类型Father及其子类的元素  因为低类型可以被高类型“兼容”
        list.add(new Father());
        list.add(new Son());
        // list.add(new Person());报错  只能填充Father类型以下的
​
​
        // 遍历时写最高类型
        // 遍历时元素类型为Object(最高类型为Object,“兼容”所有子类)
        for (Object o : list) {
            System.out.println(o);
        }
​
    }
​
}

测试：

package com.xing.generic;
​
​
import java.util.Comparator;
import java.util.TreeSet;
​
public class GenericTest {
​
    public static void main(String[] args) {
​
        // 按age排序
        TreeSet<Father> treeSet = new TreeSet<>(new Comparator2());
        treeSet.add(new Father("a",20));
        treeSet.add(new Father("b",35));
        treeSet.add(new Father("d",26));
        treeSet.add(new Father("c",19));
​
        for (Father father : treeSet) {
            System.out.println(father);
        }
        /*
            Father{age=19, name='c'}
            Father{age=20, name='a'}
            Father{age=26, name='d'}
            Father{age=35, name='b'}
         */
​
​
        // 按name排序
        TreeSet<Father> treeSet1 = new TreeSet<>(new Comparator1());
        treeSet1.add(new Father("a",20));
        treeSet1.add(new Father("b",35));
        treeSet1.add(new Father("d",26));
        treeSet1.add(new Father("c",19));
​
        for (Father father : treeSet1) {
            System.out.println(father);
        }
        /*
            Father{age=20, name='a'}
            Father{age=35, name='b'}
            Father{age=19, name='c'}
            Father{age=26, name='d'}
         */
​
        //TreeSet<Father> treeSet2 = new TreeSet<>(new Comparator3());
        // 报错  public TreeSet(Comparator<? super E> comparator) 采用下限通配符
​
    }
​
}
​
class Comparator1 implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.name.compareTo(o2.name);
    }
}
​
class Comparator2 implements Comparator<Father> {
    @Override
    public int compare(Father o1, Father o2) {
        return o1.age - o2.age;
    }
}
​
class Comparator3 implements Comparator<Son> {
    @Override
    public int compare(Son o1, Son o2) {
        return o1.level - o2.level;
    }
}

类型擦除

概念

泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为类型擦除。

分类：

• 无限制类型擦除 转化为Object类型

Generic

package com.xing.generic;
​
/*
    泛型类的定义
    泛型标识相当于类型参数
    T 在创建Generic类的对象时,需指定具体的参数类型
 */
public class Generic<T> {
    private T key;
​
    public T getKey() {
        return key;
    }
​
    public void setKey(T key) {
        this.key = key;
    }
​
​
}

GenericTest

package com.xing.generic;
​
​
import java.lang.reflect.Field;
​
public class GenericTest {
​
    public static void main(String[] args) {
​
        Generic<Integer> generic = new Generic<>();
        Class<? extends Generic> clazz = generic.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName() + ":" + field.getType().getSimpleName());//key:Object   编译结束进行类型擦除  类型变为Object
        }
​
    }
​
}

• 有限制类型擦除 转化为上限类型

Generic

package com.xing.generic;
​
/*
    泛型类的定义
    泛型标识相当于类型参数
    T 在创建Generic类的对象时,需指定具体的参数类型
 */
public class Generic<T extends Number> {
    private T key;
​
    public T getKey() {
        return key;
    }
​
    public void setKey(T key) {
        this.key = key;
    }
​
​
}

GenericTest

package com.xing.generic;
​
​
import java.lang.reflect.Field;
​
public class GenericTest {
​
    public static void main(String[] args) {
​
        Generic<Integer> generic = new Generic<>();
        Class<? extends Generic> clazz = generic.getClass();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field.getName() + ":" + field.getType().getSimpleName());//key:Number   编译结束进行类型擦除  类型变为Number
        }
​
    }
​
}

• 擦除方法中类型定义的参数 只写< T >就擦除为Object类型

Generic

package com.xing.generic;
​
import java.util.List;
​
/*
    泛型类的定义
    泛型标识相当于类型参数
    T 在创建Generic类的对象时,需指定具体的参数类型
 */
public class Generic<T extends Number> {
    private T key;
​
    // 泛型方法
    public <T extends List> T show(T t) {
        return t;
    }
​
    public <E> E print(E e) {
        return e;
    }
​
}

GenericTest

package com.xing.generic;
​
​
import java.lang.reflect.Method;
​
public class GenericTest {
​
    public static void main(String[] args) {
​
        Generic<Integer> generic = new Generic<>();
        Class<? extends Generic> clazz = generic.getClass();
​
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName()+":"+method.getReturnType().getSimpleName());
        }
        /*
            print:Object
            show:List
         */
    }
​
}

• 桥接方法

Generator

package com.xing.generic;
​
​
//泛型接口
public interface Generator<T> {
    T getKey(T t);
}

GeneratorImpl

package com.xing.generic;
​
//实现泛型接口的类，不是泛型类，需要明确实现泛型接口的数据类型。
public class GeneratorImpl implements Generator<String> {
​
    @Override
    public String getKey(String s) {
        return s;
    }
}

GenericTest

package com.xing.generic;
​
​
import java.lang.reflect.Method;
​
public class GenericTest {
​
    public static void main(String[] args) {
​
​
        Class<GeneratorImpl> clazz = GeneratorImpl.class;
​
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getName()+":"+method.getReturnType().getSimpleName());
        }
        /*
            getKey:String
            getKey:Object
         */
    }
}

 

​