java中的泛型

前言

从leetcode刷题中的一个小例子谈起，假设为了题目的需要，我们需要声明一个保存链表节点的堆栈，并且相应的入栈出栈

\*
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
*\
Stack help=new Stack();
help.push(head);
...
ListNode temp=help.pop(); 
1
2
3
4
5
6
7
8
9
10
11

上面的代码会报错
Object can not converted to ListNode

在有泛型类之前，我们只能使用Object编写适用于多种类型的代码。
java的泛型有好处也有相应的局限性。

在java实现泛型之前，泛型程序设计的功能使用继承来实现的
比如说ArrayList类

public class ArrayList // before generic classes
{
	private Object[] elementData;
	...
	public Object get(int i){...}
	public void add(Object o){...}
}
1
2
3
4
5
6
7

存在的问题：
获取特定值时必须进行类型转换

ArrayList files=new ArrayList();
String filename=(String) files.get(0);
1
2

没有错误检查,强制类型转换有时会产生错误。
泛型提供类型参数(type parameter),ArrayList有一个类型参数来指示元素的类型

var files=new ArrayList<String>();
1

泛型在集合、迭代器中的使用

能用的前提是这些类中已经声明。

泛型类、泛型接口、泛型方法

泛型类与泛型接口都比较好理解。
值得注意的是对于子父类继承的情况。

public class SubOrder extends Order<Integer> {//SubOrder:不是泛型类
}
1
2

由于子类在继承带泛型的父类时，指明了泛型类型。则实例化子类对象时，不再需要指明泛型。

public class SubOrder1<T> extends Order<T> {//SubOrder1<T>:仍然是泛型类
}
1
2

相关的注意事项：

1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
   <E1,E2,E3>

//Map中的泛型
//类型推断
Map<String,Integer>map =new HashMap<>();
map.put("Tom",87);
map.put("Jerry",87);
map.put("Jack",67);
Set<Map.Entry<String,Integer>> entry = map.entrySet();
Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();

while(iterator.hasNext()){
  Map.Entry<String, Integer> e = iterator.next();
  String key = e.getKey();
  Integer value = e.getValue();
  System.out.println(key + "----" + value);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 泛型类的构造器不使用泛型标识,泛型类的构造器如下：public GenericClass(){}。而下面是错误的：public GenericClass(){}
3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致
4. 泛型不同的引用不能相互赋值。(引用类型地址性的赋值也不行）
5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价
   于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
6. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。
   原因：我们的泛型是在创建对象的时候才指定的，而静态方法的创建要早于对象的创建
   异常类(Exception)不能是泛型的

不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity];
参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
1
2

8. 子类对父类的保留，几乎任何都可以。
   父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型

class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2 extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2> extends Father<Integer, T2> {
}
class Father<T1, T2> {
}
// 子类不保留父类的泛型
// 1)没有类型 擦除
class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
}
// 2)具体类型
class Son2<A, B> extends Father<Integer, String> {
}
// 子类保留父类的泛型
// 1)全部保留
class Son3<T1, T2, A, B> extends Father<T1, T2> {
}
// 2)部分保留
class Son4<T2, A, B> extends Father<Integer, T2> {
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

泛型方法

泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。换句话说，泛型方法所属的类是不是泛型类都没有关系。泛型方法，可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

public static <E>  List<E> copyFromArrayToList(E[] arr){

ArrayList<E> list = new ArrayList<>();

for(E e : arr){
   list.add(e);
}
return list;

}
1
2
3
4
5
6
7
8
9
10

测试类中的泛型方法

//测试泛型方法
@Test
public void test4(){
  Order<String> order = new Order<>();
  Integer[] arr = new Integer[]{1,2,3,4};
  //泛型方法在调用时，指明泛型参数的类型。
  List<Integer> list = order.copyFromArrayToList(arr);
  System.out.println(list);
}
1
2
3
4
5
6
7
8
9

泛型中的继承

如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的
类或接口，G<B>并不是G<A>的子类型！
比如：String是Object的子类，但是List<\String >并不是List<Object>
的子类,两者不能赋值。
但是： 类A是类B的父类，A 是 B 的父类

   AbstractList<String> list1 = null;
   List<String> list2 = null;
   ArrayList<String> list3 = null;

   list1 = list3;
   list2 = list3;
1
2
3
4
5
6

这可以看成泛型的一个局限。

通配符

通配符:?
作用：作为通用父类
类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类是：G<?>

 List<Object> list1 = null;
 List<String> list2 = null;
 List<?> list = null;
 list = list1;
 list = list2;
print(list1);
print(list2);
    public void print(List<?> list){
        Iterator<?> iterator = list.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            System.out.println(obj);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

添加(写入)：对于List<?>就不能向其内部添加数据,除了添加null。
获取：允许读取数据，读取的数据类型为Object。

list.add(null);
Object o = list.get(0);
System.out.println(o);
1
2
3

有限制条件的通配符

通配符指定上限
上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
通配符指定下限
下限super：使用时指定的类型不能小于操作的类，即>=
? extends A:
G<? extends A> 可以作为G<A>和G<B>的父类，其中B是A的子类

? super A:
G<? super A> 可以作为G<A>和G<B>的父类，其中B是A的父类

 List<? extends Person> list1 = null;
 List<? super Person> list2 = null;

 List<Student> list3 = new ArrayList<Student>();
 List<Person> list4 = new ArrayList<Person>();
 List<Object> list5 = new ArrayList<Object>();
 
list1 = list3;
list1 = list4;
//        list1 = list5;

//        list2 = list3;
list2 = list4;
list2 = list5;
1
2
3
4
5
6
7
8
9
10
11
12
13
14

//读取数据：
list1 = list3;
Person p = list1.get(0);
//编译不通过
//Student s = list1.get(0);

list2 = list4;
Object obj = list2.get(0);
编译不通过
//        Person obj = list2.get(0);
//写入数据：
//编译不通过
//        list1.add(new Student());
//编译通过
list2.add(new Person());
list2.add(new Student());
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16