java范型

2019-11-06 06:26:38

字体：大中小

来源：转载

供稿：网友

这里写图片描述

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; } // ... }}