这里写图片描述

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 泛型详解

原文链接：https://blog.csdn.net/qq_24145735/article/details/60598302