AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java 泛型（下）

2024-04-24 23
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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);
        }
    }
}


文章标签：
Java
关键词：
Java泛型
请回答1024
目录
相关文章
土木林森
|
4月前
|
安全 Java 编译器
揭秘JAVA深渊：那些让你头大的最晦涩知识点，从泛型迷思到并发陷阱，你敢挑战吗？
【8月更文挑战第22天】Java中的难点常隐藏在其高级特性中，如泛型与类型擦除、并发编程中的内存可见性及指令重排，以及反射与动态代理等。这些特性虽强大却也晦涩，要求开发者深入理解JVM运作机制及计算机底层细节。例如，泛型在编译时检查类型以增强安全性，但在运行时因类型擦除而丢失类型信息，可能导致类型安全问题。并发编程中，内存可见性和指令重排对同步机制提出更高要求，不当处理会导致数据不一致。反射与动态代理虽提供运行时行为定制能力，但也增加了复杂度和性能开销。掌握这些知识需深厚的技术底蕴和实践经验。
土木林森
94 2
进步`于辰
|
2月前
|
Java API
[Java]泛型
本文详细介绍了Java泛型的相关概念和使用方法，包括类型判断、继承泛型类或实现泛型接口、泛型通配符、泛型方法、泛型上下边界、静态方法中使用泛型等内容。作者通过多个示例和测试代码，深入浅出地解释了泛型的原理和应用场景，帮助读者更好地理解和掌握Java泛型的使用技巧。文章还探讨了一些常见的疑惑和误区，如泛型擦除和基本数据类型数组的使用限制。最后，作者强调了泛型在实际开发中的重要性和应用价值。
进步`于辰
41 0
[Java]泛型
bug菌
|
2月前
|
存储 安全 Java
🌱Java零基础 - 泛型详解
【10月更文挑战第7天】本文收录于「滚雪球学Java」专栏，专业攻坚指数级提升，希望能够助你一臂之力，帮你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
bug菌
19 1
2的n次方_
|
3月前
|
Java 编译器 容器
Java——包装类和泛型
包装类是Java中一种特殊类，用于将基本数据类型（如 `int`、`double`、`char` 等）封装成对象。这样做可以利用对象的特性和方法。Java 提供了八种基本数据类型的包装类：`Integer` (`int`)、`Double` (`double`)、`Byte` (`byte`)、`Short` (`short`)、`Long` (`long`)、`Float` (`float`)、`Character` (`char`) 和 `Boolean` (`boolean`)。包装类可以通过 `valueOf()` 方法或自动装箱/拆箱机制创建。
2的n次方_
44 9
Java——包装类和泛型
小强在此
|
2月前
|
Java 语音技术 容器
java数据结构泛型
java数据结构泛型
小强在此
27 5
兴化
|
2月前
|
存储 Java 编译器
Java集合定义其泛型
Java集合定义其泛型
兴化
19 1
GuGuStudy
|
2月前
|
存储 Java 编译器
【用Java学习数据结构系列】初识泛型
【用Java学习数据结构系列】初识泛型
GuGuStudy
22 2
程序员小海绵
|
3月前
|
安全 Java API
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射（2023版）
String常量池、String、StringBuffer、Stringbuilder有什么区别、List与Set的区别、ArrayList和LinkedList的区别、HashMap底层原理、ConcurrentHashMap、HashMap和Hashtable的区别、泛型擦除、ABA问题、IO多路复用、BIO、NIO、O、异常处理机制、反射
程序员小海绵
63 3
【Java面试题汇总】Java基础篇——String+集合+泛型+IO+异常+反射（2023版）
小王老师呀
|
3月前
|
存储 安全 搜索推荐
Java中的泛型
【9月更文挑战第15天】在 Java 中，泛型是一种编译时类型检查机制，通过使用类型参数提升代码的安全性和重用性。其主要作用包括类型安全，避免运行时类型转换错误，以及代码重用，允许编写通用逻辑。泛型通过尖括号 `&lt;&gt;` 定义类型参数，并支持上界和下界限定，以及无界和有界通配符。使用泛型需注意类型擦除、无法创建泛型数组及基本数据类型的限制。泛型显著提高了代码的安全性和灵活性。
小王老师呀
51 8
Codelinghu
|
2月前
|
安全 Java 编译器
Java基础-泛型机制
Java基础-泛型机制
Codelinghu
18 0

热门文章

最新文章

  • 1
    【Java多数据源实现教程】实现动态数据源、多数据源切换方式（上）
  • 2
    Java-学习笔记-8-接口
  • 3
    java中的工厂模式
  • 4
    超简单的java爬虫
  • 5
    Java 学习路线 2024 最新版！
  • 6
    从零搭建Web所需服务（四）Java连接ES进行分词并获取结果
  • 7
    迅速了解多例模式竞争者-枚举 | 带你学《Java面向对象编程》之七十四
  • 8
    带你读《Java程序设计与计算思维》之三：流程控制
  • 9
    Java Poi 创建与读取Excel
  • 10
    关于《Java数字图像处理-编程技巧与应用实践》一书 源代码
  • 1
    【Java开发指南 | 第三十一篇】Java 包(package)
    71
  • 2
    【Java开发指南 | 第二十九篇】Java接口
    46
  • 3
    【Java开发指南 | 第二十八篇】Java封装
    53
  • 4
    【Java开发指南 | 第二十六篇】Java多态
    40
  • 5
    【Java开发指南 | 第二十四篇】Java继承
    58
  • 6
    【Java开发指南 | 第九篇】访问实例变量和方法、继承、接口
    53
  • 7
    【Java开发指南 | 第八篇】Java变量、构造方法、创建对象
    92
  • 8
    Java Stream API详解与使用
    93
  • 9
    Java医院绩效考核系统源码B/S+avue+MySQL助力医院实现精细化管理
    80
  • 10
    《手把手教你》系列技巧篇（四十三）-java+ selenium自动化测试-处理https 安全问题或者非信任站点-上篇（详解教程）
    132

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    DataWorks