Java 泛型(下)

简介: Java 泛型

Java 泛型(上):https://developer.aliyun.com/article/1491136


11.3 类型通配符


当我们声明一个变量/形参时,这个变量/形参的类型是一个泛型类或泛型接口,例如:Comparator类型,但是我们仍然无法确定这个泛型类或泛型接口的类型变量<T>的具体类型,此时我们考虑使用类型通配符。

public static void forList1(List<?> list){
    for (Object o : list) {
        System.out.println(o);
    }
}
//表示此方法可以接受一个泛型是<Animal>或者List<Animal的子类型>的List集合
public static void forList2(List<? extends Animal> list){
    for (Animal animal : list) {
        System.out.println(animal);
    }
}
public static <T> void forList3(List<? extends T> list){
    for (T o : list) {
        System.out.println(o);
    }
}
public static <T> void forList3_1(List<? extends T> list,T t){
    list.add(t);//错误,无法存入数据,因为传入的List集合泛型可以是T及子类类型,如果传入的List泛型是T的子类,那么T是放不进去这个集合的
    for (T o : list) {
        System.out.println(o);
    }
    return list.get(0);//可以取出T型元素
}
//表示此方法可以接受一个泛型是<Animal>或者List<Animal的父类型>的List集合
public static void forList4(List<? super Animal> list){
    for (Object o : list) {
        System.out.println(o);
    }
}
public static<T> void forList5(List<? super T> list){
    for (Object o : list) {
        System.out.println(o);
    }
}
public static <T> T forList5_1(List<? super T> list,T t){
    list.add(t);//可以存入数据,因为传入的List集合泛型可以是T及父类类型,如果传入的List泛型是T的父类,T也可以放入这个集合中
    for (T o : list) {
        System.out.println(o);
    }
    //return list.get(0);//错误,返回值类型为T,传入的List泛型可能为T的父类型,也就可能是其中元素为T的父类的List,所以取出来元素不一定是T型
    return null;
}

例如:

这个学生类是一个参数化的泛型类,代码如下(详细请看$11.2.1中的示例说明):

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;
  }
}


11.4.1 <?>任意类型


例如:我们要声明一个学生管理类,这个管理类要包含一个方法,可以遍历学生数组。

学生管理类:

class StudentService {
  public static void print(Student<?>[] arr) {
    for (int i = 0; i < arr.length; i++) {
      System.out.println(arr[i]);
    }
  }
}

测试类

public class TestGeneric {
  public static void main(String[] args) {
    // 语文老师使用时:
    Student<String> stu1 = new Student<String>("张三", "良好");
    // 数学老师使用时:
    // Student<double> stu2 = new Student<double>("张三", 90.5);//错误,必须是引用数据类型
    Student<Double> stu2 = new Student<Double>("张三", 90.5);
    // 英语老师使用时:
    Student<Character> stu3 = new Student<Character>("张三", 'C');
    Student<?>[] arr = new Student[3];
    arr[0] = stu1;
    arr[1] = stu2;
    arr[2] = stu3;
    StudentService.print(arr);
  }
}


11.4.2 <? extends 上限>


用于设定通配符上限

例如:我们要声明一个学生管理类,这个管理类要包含一个方法,找出学生数组中成绩最高的学生对象。

要求学生的成绩的类型必须可比较大小,实现Comparable接口。

学生管理类:

class StudentService {
    //分数score的类型必须是实现了Comparable接口的
  public static Student<? extends Comparable> max(Student<? extends Comparable>[] arr){
    Student<? extends Comparable> max = arr[0];
    for (int i = 0; i < arr.length; i++) {
      if(arr[i].getScore().compareTo(max.getScore())>0){
        max = arr[i];
      }
    }
    return max;
  }
}

测试类

public class TestGeneric {
  public static void main(String[] args) {
    Student<? extends Double>[] arr = new Student[3];
    arr[0] = new Student<Double>("张三", 90.5);
    arr[1] = new Student<Double>("李四", 80.5);
    arr[2] = new Student<Double>("王五", 94.5);
    
    Student<? extends Comparable> max = StudentService.max(arr);
    System.out.println(max);
  }
}


11.4.3 <? super 下限>


用于设定通配符下限

现在要声明一个数组工具类,包含可以给任意对象数组进行从小到大排序,只要你指定定制比较器对象,而且这个定制比较器对象可以是当前数组元素类型自己或其父类的定制比较器对象

数组工具类:

class MyArrays{
  public static <T> void sort(T[] arr, Comparator<? super T> c){
    for (int i = 1; i < arr.length; i++) {
      for (int j = 0; j < arr.length-i; j++) {
        if(c.compare(arr[j], arr[j+1])>0){
          T temp = arr[j];
          arr[j] = arr[j+1];
          arr[j+1] = temp;
        }
      }
    }
  }
}

例如:有如下JavaBean

class Person{
  private String name;
  private int age;
  public Person(String name, int age) {
    super();
    this.name = name;
    this.age = age;
  }
  public Person() {
    super();
  }
  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 "name=" + name + ", age=" + age;
  }
}
class Student extends Person{
  private int score;
  public Student(String name, int age, int score) {
    super(name, age);
    this.score = score;
  }
  public Student() {
    super();
  }
  public int getScore() {
    return score;
  }
  public void setScore(int score) {
    this.score = score;
  }
  @Override
  public String toString() {
    return super.toString() + ",score=" + score;
  }
  
}

测试类

public class TestGeneric {
  public static void main(String[] args) {
    Student[] all = new Student[3];
    all[0] = new Student("张三", 23, 89);
    all[1] = new Student("李四", 22, 99);
    all[2] = new Student("王五", 25, 67);
    
    MyArrays.sort(all, new Comparator<Person>() {
      @Override
      public int compare(Person o1, Person o2) {
        return o1.getAge() - o2.getAge();
      }
    });
    
    System.out.println(Arrays.toString(all));
    
    MyArrays.sort(all, new Comparator<Student>() {
      @Override
      public int compare(Student o1, Student o2) {
        return o1.getScore() - o2.getScore();
      }
    });
    System.out.println(Arrays.toString(all));
  }
}


练习:

在数组工具类中声明如下泛型方法:

(1)可以在任意类型的对象数组中,查找某个元素的下标,按照顺序查找,如果有重复的,就返回第一个找到的,如果没有返回-1

(2)可以在任意类型的对象数组中,查找最大值,要求元素必须实现Comparable接口

(3)可以在任意类型的对象数组中,查找最大值,按照指定定制比较器来比较元素大小

(4)可以给任意对象数组进行从小到大排序,要求数组元素类型必须实现Comparable接口

(5)可以给任意对象数组进行从小到大排序,只要你指定定制比较器对象,不要求数组元素实现Comparable接口

(6)可以将任意对象数组的元素拼接为一个字符串返回

public class MyArrays {
  //可以在任意类型的对象数组中,查找某个元素的下标,按照顺序查找,如果有重复的,就返回第一个找到的,如果没有返回-1
  public static <T> int find(T[] arr, T value) {
    for (int i = 0; i < arr.length; i++) {
      if(arr[i].equals(value)) {//使用==比较太严格,使用equals方法,因为任意对象都有equals方法
        return i;
      }
    }
    return -1;
  }
  
  //可以在任意类型的对象数组中,查找最大值,要求元素必须实现Comparable接口
  public static <T extends Comparable<? super T>> T max(T[] arr) {
    T max = arr[0];
    for (int i = 0; i < arr.length; i++) {
      if(max.compareTo(arr[i])<0) {//if(max < arr[i]) {
        max = arr[i];
      }
    }
    return max;
  }
  
  //可以在任意类型的对象数组中,查找最大值,按照指定定制比较器来比较元素大小
  public static <T> T max(T[] arr, Comparator<? super T> c) {
    T max = arr[0];
    for (int i = 0; i < arr.length; i++) {
      if(c.compare(max, arr[i])<0) {//if(max < arr[i]) {
        max = arr[i];
      }
    }
    return max;
  }
  
  //可以给任意对象数组进行从小到大排序,要求数组元素类型必须实现Comparable接口
  public static <T extends Comparable<? super T>> void sort(T[] arr) {
    for (int i = 0; i < arr.length-1; i++) {
      int minIndex = i;
      for (int j = i+1; j < arr.length; j++) {
        if(arr[minIndex].compareTo(arr[j])>0) {
          minIndex = j;
        }
      }
      if(minIndex!=i) {
        T temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
      }
    }
  }
  
  //可以给任意对象数组进行从小到大排序,只要你指定定制比较器对象,不要求数组元素实现Comparable接口
  public static <T> void sort(T[] arr, Comparator<? super T> c) {
    for (int i = 0; i < arr.length-1; i++) {
      int minIndex = i;
      for (int j = i+1; j < arr.length; j++) {
        if(c.compare(arr[minIndex],arr[j])>0) {
          minIndex = j;
        }
      }
      if(minIndex!=i) {
        T temp = arr[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
      }
    }
  }
  
  //可以将任意对象数组的元素拼接为一个字符串返回
  public static <T> String toString(T[] arr) {
    String str = "[";
    for (int i = 0; i < arr.length; i++) {
      if(i==0) {
        str += arr[i];
      }else {
        str += "," + arr[i];
      }
    }
    str += "]";
    return str;
  }
}


通配符演示示例:

public class TestWildcardType {
    @Test
    public void test1() {
        List<String> list = new ArrayList<>();
        //使用只能处理泛型参数为String的List集合的方法
        handleStringList(list);
        List<?> list1 = new ArrayList<String>();
        List<?> list2 = new ArrayList<Integer>();
        List<?> list3 = new ArrayList<Object>();
        //可以处理任意泛型参数的List集合
        handleList(list1);
        handleList(list2);
        handleList(list3);
    }
    //定义一个方法,只能处理泛型参数为String的List集合
    public  void handleStringList(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
    @Test
    public void test2() {
        //一、使用通配符?
        List<?> list;//泛型变量可以是任意类型
        list = new ArrayList<>();//泛型变量默认是Object类型的泛型
        list = new ArrayList<Object>();
        list = new ArrayList<String>();
        list = new ArrayList<Number>();
        list = new ArrayList<Integer>();
//        list.add(1);//compile error 编译器无法确定要add的真实类型,可能是<Character>或<Byte>,那么add(0.5)不可以,只有在方法被调用时才能确定。
        Object o = list.get(0);//无法确定元素类型,只能使用Object接收
        //二、设定通配符上限
        List<? extends Number> list1;//泛型变量必须是Number子类类型
        list1 = new ArrayList<>();//泛型变量默认是 Number类型
//        list1 = new ArrayList<Object>();//compile error
        list1 = new ArrayList<Number>();
        list1 = new ArrayList<Double>();
//        list1.add(1);//compile error 编译器无法确定要add的真实类型,可能是<Character>或<Byte>,那么add(0.5)不可以,只有在方法被调用时才能确定。
        Number number = list1.get(0);//可以使用Number接收,自动向上转型
        //所以设定了通配符上限,通常只能获取数据,即生产数据
        //三、设定通配符下限
        List<? super Number> list2;//泛型变量必须是Number父类类型
        list2 = new ArrayList<>();//泛型变量默认是 Number类型,
        list2 = new ArrayList<Object>();
        list2 = new ArrayList<Number>();
//        list2 = new ArrayList<Integer>();//compile error
        //
        list2.add(1.2);//编译器可以确定要add的真实类型一定是数值类型父类,那么add一个数值类型就不会有问题。
        Object object = list2.get(0);//返回值类型只能确定是Number的超类,编译器不确定具体类型,只能使用Object接收
        //所以设定通配符下限,通常用于添加数据,修改数据等即消费数据
    }
    //1.使用通配符,可以接收任意泛型的List集合
    public void handleList(List<?> list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(0));
        }
    }
    //2.设定通配符上限
    //定义一个方法,只能处理装有数值类型元素的List集合
    public void handleNumberList(List<? extends Number> list){
        double sum=0;
        for (Number number : list) {
            sum += number.doubleValue();
        }
        System.out.println(sum);
    }
    //3.设定通配符下限
    //定一个方法,需要一个比较器,只要能处理T类型数据的比较器就可以
    //比如要比较T[]的数组元素大小,那么就需要一个可以比较T类型元素或能比较T的父类型元素(一定能比较T)的比较器
    public <T> void  handleComparator(T[] arr,Comparator<? super T> c){
    }
    //3.1设定通配符下限
    //定义一个方法,可以向任意List集合中(泛型类型下限为T型的集合),添加T型元素(泛型类型下限为T型的集合一定可以添加T型元素)
    public static <T> void fill(List<? super T> list,T obj){
        for (int i = 0; i < list.size(); i++) {
            list.add(obj);
        }
    }
}
();
        list2 = new ArrayList<Number>();
//        list2 = new ArrayList<Integer>();//compile error
        //
        list2.add(1.2);//编译器可以确定要add的真实类型一定是数值类型父类,那么add一个数值类型就不会有问题。
        Object object = list2.get(0);//返回值类型只能确定是Number的超类,编译器不确定具体类型,只能使用Object接收
        //所以设定通配符下限,通常用于添加数据,修改数据等即消费数据
    }
    //1.使用通配符,可以接收任意泛型的List集合
    public void handleList(List<?> list){
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(0));
        }
    }
    //2.设定通配符上限
    //定义一个方法,只能处理装有数值类型元素的List集合
    public void handleNumberList(List<? extends Number> list){
        double sum=0;
        for (Number number : list) {
            sum += number.doubleValue();
        }
        System.out.println(sum);
    }
    //3.设定通配符下限
    //定一个方法,需要一个比较器,只要能处理T类型数据的比较器就可以
    //比如要比较T[]的数组元素大小,那么就需要一个可以比较T类型元素或能比较T的父类型元素(一定能比较T)的比较器
    public <T> void  handleComparator(T[] arr,Comparator<? super T> c){
    }
    //3.1设定通配符下限
    //定义一个方法,可以向任意List集合中(泛型类型下限为T型的集合),添加T型元素(泛型类型下限为T型的集合一定可以添加T型元素)
    public static <T> void fill(List<? super T> list,T obj){
        for (int i = 0; i < list.size(); i++) {
            list.add(obj);
        }
    }
}


相关文章
|
7天前
|
存储 Java 编译器
深入理解 Java 泛型和类型擦除
【4月更文挑战第19天】Java泛型是参数化类型,增强安全性与可读性,但存在类型擦除机制。类型擦除保证与旧版本兼容,优化性能,但也导致运行时无法访问泛型信息、类型匹配问题及数组创建限制。为应对这些问题,可使用Object类、instanceof运算符,或借助Guava库的TypeToken获取运行时类型信息。
|
7天前
|
JavaScript Java 编译器
Java包装类和泛型的知识点详解
Java包装类和泛型的知识点的深度理解
|
7天前
|
安全 Java 程序员
Java 泛型
Java 泛型
16 0
|
2天前
|
安全 Java 编译器
Java一分钟之——泛型方法与泛型接口
【5月更文挑战第20天】Java泛型提供编译时类型安全检查,提升代码重用和灵活性。本文探讨泛型方法和接口的核心概念、常见问题和避免策略。泛型方法允许处理多种数据类型,而泛型接口需在实现时指定具体类型。注意类型擦除、误用原始类型和泛型边界的理解。通过明确指定类型参数、利用通配符和理解类型擦除来避免问题。泛型接口要精确指定类型参数,适度约束,利用默认方法。示例代码展示了泛型方法和接口的使用。
27 1
Java一分钟之——泛型方法与泛型接口
|
2天前
|
存储 安全 Java
Java一分钟之-泛型擦除与类型安全
【5月更文挑战第20天】Java泛型采用类型擦除机制,在编译期间移除泛型信息,但在编译阶段提供类型安全检查。尽管需要类型转换且可能产生警告,但可以通过特定语法避免。使用泛型时应注意自动装箱拆箱影响性能,无界通配符仅允许读取。理解这些特性有助于编写更安全的代码。
27 4
|
3天前
|
安全 Java API
Java一分钟之-泛型通配符:上限与下限野蛮类型
【5月更文挑战第19天】Java中的泛型通配符用于增强方法参数和变量的灵活性。通配符上限`? extends T`允许读取`T`或其子类型的列表,而通配符下限`? super T`允许向`T`或其父类型的列表写入。野蛮类型不指定泛型,可能引发运行时异常。注意,不能创建泛型通配符实例,也无法同时指定上下限。理解和适度使用这些概念能提升代码的通用性和安全性,但也需兼顾可读性。
25 3
|
7天前
|
安全 Java 编译器
java泛型浅谈
java泛型浅谈
8 1
|
7天前
|
存储 安全 Java
掌握8条泛型规则,打造优雅通用的Java代码
掌握8条泛型规则,打造优雅通用的Java代码
掌握8条泛型规则,打造优雅通用的Java代码
|
7天前
|
Java
JAVA难点包括异常处理、多线程、泛型和反射,以及复杂的分布式系统知识
【5月更文挑战第2天】JAVA难点包括异常处理、多线程、泛型和反射,以及复杂的分布式系统知识。入坑JAVA因它的面向对象特性、平台无关性、强大的标准库和活跃的社区支持。
42 2
|
7天前
|
安全 Java 编译器
【JAVA】泛型和Object的区别
【JAVA】泛型和Object的区别