今天在写代码的时候，看见这样的一段代码，然后知道自己还没有把泛型吃透，就花了一点时间再研究研究，因为之前写代码的时候涉及到的泛型都是简单的泛型，比如一个List<String> 这样的，限定类型的，但是一个随着自己接触的越来越广，难免会用到复杂的泛型:
public static <K, V extends Comparable<? super V>> Map sortByValues(Map<K, V> map) {
List<Map.Entry<K, V>> list = new LinkedList<>(map.entrySet());
Collections.sort(list, Comparator.comparing(Map.Entry::getValue));
Map<K, V> result = new LinkedHashMap<>();
for (Map.Entry<K, V> entry : list) {
result.put(entry.getKey(), entry.getValue());
}
return result;
}
这个方法的作用大家应该很容易能够看明白，就是给一个Map按照Value进行排序，排序的规则，由Value的Comparable去定义的。功能是很容易看明白，但是这里面的一个K，V还有通配符?，表示着什么意思呢？
1.泛型类和泛型方法
public class Generic<T> {
private T info;
/**
* 泛型方法
* */
public <E> void print(E t) {
System.out.println(t);
}
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
public static void main(String[] args) {
//泛型类，在类名上加入泛型，然后可以看出里面的info字段类型，可以用这泛型类型所表示
//这里传入String的类型，以后的T就是String类型，编译的时候编译器会自动的做类型检查
Generic<String> generic = new Generic();
generic.setInfo("generic");
System.out.println(generic.getInfo());
//可以看到上面还有个print泛型方法，因为参数总还有未知类型，可以看到下面在调用方法的时候
//传入不同的类型，都可以进行适配
generic.print(1);
generic.print("this is String");
}
output:
generic
1
this is String
2.限制类的泛型
限制类的泛型有 extends 和 super
如 ：
List<T extends Number> list1
List<? super Double> list2
上限制:list1表示的是Number 或者Number子类的列表,如果Number是接口的话,也可以表示实现Number接口的所有类
下限制:list2表示的是Double 或者Double父类的列表
先来看一个上限制的例子:
public class GenericAgain {
/**
* 泛型方法
* T 就是调用这个方法的时候传入的类型
* S 这个有点限制 是T或者其子类型
* */
public <T, S extends T> T generic(T t, S s) {
System.out.println(t);
System.out.println(s);
if (s != null) {
return s;
}
return t;
}
public static void main(String[] args) {
GenericAgain genericAgain = new GenericAgain();
A a = new A();
a.setId(1);
B b = new B();
b.setId(2);
b.setInfo("info");
genericAgain.generic(a, b);
}
}
class A {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "A{" +
"id=" + id +
'}';
}
}
class B extends A {
private String info;
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
@Override
public String toString() {
return super.toString() + "B{" +
"info='" + info + '\'' +
'}';
}
}
output:
A{id=1}
A{id=2}B{info='info'}
再来看一个下限制的例子:
在这之前我们先看一下List<?>, List, List<Object>, List<? extends Object>各有什么区别？
List<?>表示无界通配符, 并非表示任意类型, 而是表示一个具体类型, 但是这个具体类型是什么我们编程的时候并不关心; List表示原生list, 没有泛型参数的list, 这个没有什么可以说的, 不推荐使用; List<Object> 表示的是这个list存放的是Object, 只要是Object就可以放入; 最后List<? extends Object>表示一个集合,这个集合存放的是Object具体子类中的某一种, 而非只要是object的子类就可以放入.
不过这些差异仅仅是在编译时编译器产生的, 到了运行时, 由于擦除, 全部都是List<Object>
class A1 {
public void test() {
System.out.println("A1");
}
@Override
public String toString() {
return "A1{}";
}
}
class B1 extends A1 {
@Override
public void test() {
System.out.println("B1");
}
@Override
public String toString() {
return "B1{}";
}
}
class C1{
}
class D1 {
public static void generic(List<?> list) {
list.stream().forEach(System.out::println);
}
public static void genericSpecific(List<? super B1> list) {
list.stream().forEach(System.out::println);
}
public static void main(String[] args) {
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
D1.generic(integerList);
List<String> stringList = Arrays.asList("first", "second", "third", "fourth", "fifth");
D1.generic(stringList);
List<A1> a1List = new ArrayList<>();
List<B1> b1List = new ArrayList<>();
List<C1> c1List = new ArrayList<>();
for (int i = 0; i < 2; i++) {
a1List.add(new A1());
b1List.add(new B1());
c1List.add(new C1());
}
D1.genericSpecific(a1List);
D1.genericSpecific(b1List);
// D1.genericSpecific(c1List);
}
}
output:
1
2
3
4
5
first
second
third
fourth
fifth
A1{}
A1{}
B1{}
B1{}
上面这部分代码有一行被注释掉了，如果恢复这部分代码，编译器会报错，提示D1.genericSpecific传入的必须是B1或者其super类型。
泛型的时候会有很多符号，比如T E K V 等等，这些符号只是便于记忆，比如说T 表示的是Type，E 表示的是Element ,K 表示的是Key V 表示的是V，K V 一般一起用在Map里面，T一般用在泛型类和泛型方法里面，E一般用在泛型类里面，比如说java 里的集合一般都是用E，来表示内部的元素。
