Java 之 泛型的其他知识

一、并不存在泛型类的 Class 对象

　　1、Type<String> 和 Type<Integer> 的区别？

　　　　 通过泛型使得一个类型的功能增强了，好像扩展出好多子类一样。

　　　　 例如：ArrayList<E>，通过指定泛型，可以延伸出 ArrayList<String> 只能处理字符串类型的集合，ArrayList<Employee> 只能处理 Employee 员工类型的集合。但是，实际上，系统并没有为 ArrayList<String> 等生成新的 class 文件，而且也不会把 ArrayList<String> 当成新的类型处理。

　　　　看下面的代码的打印结果是什么？

        ArrayList<Integer> list1 = new ArrayList<Integer>();
        ArrayList<String> list2 = new ArrayList<String>();
        System.out.println(list1.getClass());
        System.out.println(list2.getClass());
        System.out.println(list1.getClass() == list2.getClass()); //true

　　　　可见，ArrayList<String> 不是 ArrayList<Object> 的子类，因为它们的运行时类型都是 ArrayList，因此不允许如下赋值操作。

ArrayList<Object> list = new ArrayList<String>();   //错误的

　　　　  这点和数组不同，因为数组要生成新的 Class 对象的，String[] 仍然是 Object[] 的子类，因此允许如下赋值操作。

Object[] arr = new String[5];

　　　　  但是数组这么处理也是有风险的，如下操作编译正确，但运行时会报 ArrayStoreException，所以请谨慎这样操作。

        Object[] arr = new String[5];
        arr[0] = 12;//因为12不是字符串对象

　　2、instanceof 后面不支持泛型类

　　　　由于系统中并不会真正生成泛型类，所以如下操作也都是不允许的：

        ArrayList<String> list = new ArrayList<String>();
       //编译错误，instanceof后面不能使用泛型类
        if(list instanceof ArrayList<String>){
            
        }

　　3、泛型与数组

　　　　 数组的元素类型不能包含类型变量或类型形参，除非是无上限的类型通配符。

    public static void main(String[] args) {
        List<?>[] arr = new List<?>[2];
        arr[0] = Arrays.asList("hello","java");
        arr[1] = Arrays.asList(1,2,3);
        for (List<?> list : arr) {
            for (Object object : list) {
                System.out.println(object);
            }
        }
    }

　　　　只能声明这样的数组，但是不能创建这样的数组对象，以下代码编译错误：

ArrayList<String>[] array = new ArrayList<String>[5]; //编译错误

　　　　  以下代码也是错误的：

class MyClass<T>{
    private T[] arr;

    public MyClass(int length) {
        super();
        this.arr = new T[length];                                        
    }
}

　　4、泛型与异常

　　　　不能在 try-catch 中使用类型变量，也不能在 throws 后面使用类型变量。

二、泛型嵌套：从外到内分析

　　案例：已知有省份 Provice 类型，有属性省份编号id和名称 name，有城市 City 类型，有属性城市编号id和名称 name,所属省份编号 pid.如果要存储如下信息到一个 Map 中，该如何指定泛型呢？其中 key为省份对象，value 为该省份对应的所有城市对象。

　　

 　　分析：key 的类型为 Provice，而 value 要保存多个城市对象，因此是一个 List 或 Set，因此泛型实参为 City类型。如：TreeMap<Province,TreeSet<City>>。

　　完整代码示例：

　　　　Provice 类

public class Province implements Comparable<Province>{
    private int id;
    private String name;
    public Province(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    public Province() {
        super();
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return id + ":" + name;
    }
    @Override
    public int compareTo(Province o) {
        return this.id - o.id;
    }
}

 　　City 类：

public class City implements Comparable<City>{
    private int id;
    private String name;
    private int pid;
    public City(int id, String name, int pid) {
        super();
        this.id = id;
        this.name = name;
        this.pid = pid;
    }
    public City() {
        super();
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getPid() {
        return pid;
    }
    public void setPid(int pid) {
        this.pid = pid;
    }
    @Override
    public String toString() {
        return id + ":" + name;
    }
    @Override
    public int compareTo(City o) {
        return this.id - o.id;
    }
}

　　测试类：

import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

public class AreaManager {
    public static void main(String[] args) {
         //key为Province，value是一个TreeSet<City>
        TreeMap<Province,TreeSet<City>> map = new TreeMap<Province,TreeSet<City>>();
                
        TreeSet<City> bj = new TreeSet<City>();
        bj.add(new City(1,"北京市",1));
        map.put(new Province(1,"北京市"), bj);
        
        TreeSet<City> hn = new TreeSet<City>();
        hn.add(new City(1,"海口市",2));
        hn.add(new City(2,"三亚市",2));
        map.put(new Province(2,"海南省"), hn);
        
        TreeSet<City> zj = new TreeSet<City>();
        zj.add(new City(1,"绍兴市",3));
        zj.add(new City(2,"温州市",3));
        zj.add(new City(3,"湖州市",3));
        zj.add(new City(4,"嘉兴市",3));
        zj.add(new City(5,"台州市",3));
        zj.add(new City(6,"金华市",3));
        zj.add(new City(7,"舟山市",3));
        zj.add(new City(8,"衢州市",3));
        zj.add(new City(9,"丽水市",3));
        map.put(new Province(3,"浙江省"), zj);
        //Map中实际存储的是一个个的Entry对象，所有的Entry就组成了一个Set集合
//而Entry类型的key是Province，value是TreeSet<City>
        Set<Entry<Province, TreeSet<City>>> entrySet = map.entrySet();
        for (Entry<Province, TreeSet<City>> entry : entrySet) {
            Province key = entry.getKey();
            System.out.println(key);
            TreeSet<City> value = entry.getValue();
            for (City city : value) {
                System.out.println("	" + city);
            }
        }
    }
}