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