java范型

Java泛型由来的动机

• 理解Java泛型最简单的方法是把它看成一种便捷语法，能节省你某些Java类型转换(casting)上的操作；以及防止代码运行时出现ClassCastException。

泛型的构成

• 范型类、范型接口

public interface List<T> extends Collection<T> {  //get方法实际返回的是一个类型为T的对象，T是在List<T>声明中的类型变量。  T get(int index);  <T1> void put(T1 t);  Iterator<E> iterator();...}

• 泛型方法和构造器(Constructor)

//如果方法和构造器上声明了一个或多个类型变量，它们也可以泛型化//使用场景：静态、final、工具类public final class Collections2 {  public static <E> Collection<E> filter(Collection<E> unfiltered, Predicate<? super E> predicate) {    ... }}

遍历使用

• 类库中的很多类，诸如Iterator，功能都有所增强，被泛型化。List接口里的iterator()方法现在返回的是Iterator，由它的T next()方法返回的对象不需要再进行类型转换，你直接得到正确的类型。
• 使用foreach,“for each”语法同样受益于泛型。

for (Iterator<String> iter = str.iterator(); iter.hasNext();) {String s = iter.next();System.out.print(s);}for (String s: str) {System.out.print(s);}

自动封装(Autoboxing)和自动拆封(Autounboxing)

• 在使用Java泛型时，autoboxing/autounboxing这两个特征会被自动的用到，就像下面的这段代码：

List<Integer> ints = new ArrayList<Integer>();ints.add(0);ints.add(1);int sum = 0;for (int i : ints) {sum += i;}

• 要明白的一点是，封装和解封会带来性能上的损失

通配符

• “Producer Extends” – 如果你需要一个只读List，用它来produce T，那么使用? extends T。
• “Consumer Super” – 如果你需要一个只写List，用它来consume T，那么使用? super T。

• 如果需要同时读取以及写入，那么我们就不能使用通配符了。

• 如何阅读过一些Java集合类的源码，可以发现通常我们会将两者结合起来一起用，比如像下面这样：

public class Collections {    public static <T> void copy(List<? super T> dest, List<? extends T> src) {        for (int i=0; i<src.size(); i++)            dest.set(i, src.get(i));    }}

类型擦除

　　- Java泛型中最令人苦恼的地方或许就是类型擦除了，特别是对于有C++经验的程序员。类型擦除就是说Java泛型只能用于在编译期间的静态类型检查，然后编译器生成的代码会擦除相应的类型信息，这样到了运行期间实际上JVM根本就知道泛型所代表的具体类型。这样做的目的是因为Java泛型是1.5之后才被引入的，为了保持向下的兼容性，所以只能做类型擦除来兼容以前的非泛型代码。对于这一点，如果阅读Java集合框架的源码，可以发现有些类其实并不支持泛型。

public class Generic {    static List<Apple> apples = Arrays.asList(new Apple());    static List<Fruit> fruit = Arrays.asList(new Fruit());    static class Reader<T> {        T readExact(List<T> list) {            return list.get(0);        }    }    static void f1() {        Reader<Fruit> fruitReader = new Reader<Fruit>();        // Errors: List<Fruit> cannot be applied to List<Apple>.        // Fruit f = fruitReader.readExact(apples);    }    //但是按照我们通常的思维习惯，Apple和Fruit之间肯定是存在联系，然而编译器却无法识别，    // 那怎么在泛型代码中解决这个问题呢？我们可以通过使用通配符来解决这个问题：    static class CovariantReader<T> {        T readCovariant(List<? extends T> list) {            return list.get(0);        }    }    static void f2() {        CovariantReader<Fruit> fruitReader = new CovariantReader<Fruit>();        Fruit f = fruitReader.readCovariant(fruit);        Fruit a = fruitReader.readCovariant(apples);    }    static void add() {        // Wildcards allow covariance:        List<? extends Fruit> flist = new ArrayList<Apple>();        // Compile Error: can't add any type of object:        // flist.add(new Apple())        // flist.add(new Orange())        // flist.add(new Fruit())        // flist.add(new Object())        flist.add(null); // Legal but uninteresting        // We Know that it returns at least Fruit:        Fruit f = flist.get(0);        //答案是否定，Java编译器不允许我们这样做，为什么呢？        // 对于这个问题我们不妨从编译器的角度去考虑。因为List<? extends Fruit> flist它自身可以有多种含义：//        List<? extends Fruit> flist = new ArrayList<Fruit>();//        List<? extends Fruit> flist = new ArrayList<Apple>();//        List<? extends Fruit> flist = new ArrayList<Orange>();    }    public static void main(String[] args) {        f1();        f2();    }    static class Fruit {    }    static class Apple extends Fruit {    }    static class Orange extends Fruit {    }}

• 4种案例

public class Test2 {    public static void quetion1() {        //问题一:在Java中不允许创建泛型数组，类似下面这样的做法编译器会报错：        List<Integer>[] arrayOfLists = new List<Integer>[2];  // compile-time error        //对于下面这段代码还是很好理解，字符串数组不能存放整型元素，        //而且这样的错误往往要等到代码运行的时候才能发现，编译器是无法识别的。        Object[] strings = new String[2];        strings[0] = "hi";   // OK        strings[1] = 100;    // An ArrayStoreException is thrown.        //由于运行时期类型信息已经被擦除，JVM实际上根本就不知道new ArrayList<String>()和new ArrayList<Integer>()的区别        Class c1 = new ArrayList<String>().getClass();        Class c2 = new ArrayList<Integer>().getClass();        System.out.println(c1.getName() + c2.getName() + (c1 == c2)); // true    }    //问题二(还没理解,参看尾部的参考):继续复用我们上面的Node的类，对于泛型代码，Java编译器实际上还会偷偷帮我们实现一个Bridge method。?    public static void question2() {        //最佳实践，建设类型推断，显示设置返回类型。    }    //　问题三:正如我们上面提到的，Java泛型很大程度上只能提供静态类型检查，    // 然后类型的信息就会被擦除，所以像下面这样利用类型参数创建实例的做法编译器不会通过：    public static <E> void append(List<E> list) {        E elem = new E();  // compile-time error        list.add(elem);    }    //但是如果某些场景我们想要需要利用类型参数创建实例，我们应该怎么做呢？可以利用反射解决这个问题：    public static <E> void append(List<E> list, Class<E> cls) throws Exception {        E elem = cls.newInstance();   // OK        list.add(elem);//        List<String> ls = new ArrayList();//        append(ls, String.class);    }    //问题四:我们无法对泛型代码直接使用instanceof关键字，    //因为Java编译器在生成代码的时候会擦除所有相关泛型的类型信息，    //正如我们上面验证过的JVM在运行时期无法识别出ArrayList<Integer>和ArrayList<String>的之间的区别：    public static <E> void rtt(List<E> list) {        if (list instanceof ArrayList<Integer>) {  // compile-time error            // ...        }    }    //和上面一样，我们可以使用通配符重新设置bounds来解决这个问题：    public static void rtti(List<?> list) {        if (list instanceof ArrayList<?>) {  // OK; instanceof requires a reifiable type            // ...        }    }    public class Node<T extends Comparable<T>> {        private T data;        private Node<T> next;        public Node(T data, Node<T> next) {            this.data = data;            this.next = next;        }        public T getData() {            return data;        }        // ...    }}

Effective Java 范型

• 不要在新代码中使用原生态类型：Set< Object >是个参数化类型，可以包含任何对象类型的一个集合；Set< ?>则是一个通配符类型，表示可以包含某种未知对象类型的一个集合；Set 则是一个原生态类型，它脱离类范型系统。前两者是安全的，后一种不安全。

• 消除 unchecked cast warnings;unchecked conversion warnings.

• 列表优先于数组：数组提供了运行时的类型安全，但是没有编译时的类型安全。

• Java 泛型详解