Java 泛型详解

引言

泛型是Java中三个非常关键的知识点,在Java群集类框架中泛型被普遍应用。本文大家将从零最早来看一下Java泛型的规划,将会涉嫌到通配符处理,以至令人非常的慢的品种擦除。

泛型基本功

泛型类

我们率先定义二个精简的Box类:

public class Box {
    private String object;
    public void set(String object) { this.object = object; }
    public String get() { return object; }
}

那是最遍布的做法,这样做的多少个害处是Box里面以后只得装入String类型的要素,现在只要大家必要装入Integer等别的项目标因素,还非得要此外重写贰个Box,代码得不到复用,使用泛型可以很好的消除那些主题素材。

public class Box<T> {
    // T stands for "Type"
    private T t;
    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

这么我们的Box类便能够赢得复用,大家能够将T替换到任何大家想要的项目:

Box<Integer> integerBox = new Box<Integer>();
Box<Double> doubleBox = new Box<Double>();
Box<String> stringBox = new Box<String>();

泛型方法

看完了泛型类,接下去大家来了然一下泛型方法。声圣元(KaricareState of Qatar个泛型方法很简短,只要在回来类型前面加上二个好像<K, V>的款型就能够了:

public class Util {
    public static <K, V> boolean compare(Pair<K, V> p1, Pair<K, V> p2) {
        return p1.getKey().equals(p2.getKey()) &&
               p1.getValue().equals(p2.getValue());
    }
}
public class Pair<K, V> {
    private K key;
    private V value;
    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    public void setKey(K key) { this.key = key; }
    public void setValue(V value) { this.value = value; }
    public K getKey()   { return key; }
    public V getValue() { return value; }
}

澳门新葡萄京官网注册,咱俩得以像上面那样去调用泛型方法:

Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.<Integer, String>compare(p1, p2);

要么在Java1.7/1.8运用type inference,让Java自动推导出相应的花色参数:

Pair<Integer, String> p1 = new Pair<>(1, "apple");
Pair<Integer, String> p2 = new Pair<>(2, "pear");
boolean same = Util.compare(p1, p2);

边界符

近些日子大家要实现如此叁个效果,查找一个泛型数组中胜出某些特定成分的个数,大家得以这么完毕:

public static <T> int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e > elem)  // compiler error
            ++count;
    return count;
}

但是这么很明显是大错特错的,因为除却short, int, double, long, float, byte, char等原始类型,别的的类并不一定能应用操作符>,所以编写翻译器报错,那怎么化解这一个标题啊?答案是行使边界符。

public interface Comparable<T> {
    public int compareTo(T o);
}

做四个近乎于上面这样的证明,那样就相当于告诉编写翻译器类型参数T意味着的都是落到实处了Comparable接口的类,那样等于告诉编写翻译器它们都最少实现了compareTo方法。

public static <T extends Comparable<T>> int countGreaterThan(T[] anArray, T elem) {
    int count = 0;
    for (T e : anArray)
        if (e.compareTo(elem) > 0)
            ++count;
    return count;
}

通配符

在摸底通配符在此之前,我们先是必必要清淤三个概念,照旧借用大家地点定义的Box类,倘诺大家加多一个这么的秘技:

public void boxTest(Box<Number> n) { /* ... */ }

那么今后Box<Number> n同意选用什么项目标参数?大家是否能够传入Box<Integer>或者Box<Double>啊?答案是不是定的,固然Integer和Double是Number的子类,可是在泛型中Box<Integer>或者Box<Double>Box<Number>里面并不曾别的的关联。那点卓殊首要,接下去大家透过三个完整的例子来加强一下掌握。

先是大家先定义几个大约的类,下边大家将运用它:

class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}

下边那么些例子中,大家创设了二个泛型类Reader,然后在f1()中当大家尝试Fruit f = fruitReader.readExact(apples);编写翻译器会报错,因为List<Fruit>List<Apple>里头并从未别的的涉及。

public class GenericReading {
    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);
    }
    public static void main(String[] args) {
        f1();
    }
}

唯独依据我们管见所及的思维习贯,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);
}
public static void main(String[] args) {
    f2();
}

如此就万分与报告编写翻译器,
fruitReader的readCovariant方法选拔的参数只如果满足Fruit的子类就能够(包蕴Fruit自个儿State of Qatar,这样子类和父类之间的关系也就涉及上了。

PECS原则

地点大家看来了雷同<? extends T>的用法,利用它大家能够从list里面get成分,那么大家可不得现在list里面add成分呢?大家来品尝一下:

public class GenericsAndCovariance {
    public static void main(String[] args) {
        // 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>();
  • 当大家尝试add一个Apple的时候,flist可能针对new ArrayList<Orange>();
  • 当大家尝试add八个Orange的时候,flist恐怕针对new ArrayList<Apple>();
  • 当大家品尝add三个Fruit的时候,那么些Fruit能够是任何项指标Fruit,而flist也许只想某种特定类型的Fruit,编写翻译器一点都不大概辨识所以会报错。

之所以对于贯彻了<? extends T>的群集类只可以将它正是Producer向外提供(get卡塔尔国元素,而无法作为Consumer来对外获取(add卡塔尔成分。

借使大家要add元素应该怎么做吧?能够利用<? super T>

public class GenericWriting {
    static List<Apple> apples = new ArrayList<Apple>();
    static List<Fruit> fruit = new ArrayList<Fruit>();
    static <T> void writeExact(List<T> list, T item) {
        list.add(item);
    }
    static void f1() {
        writeExact(apples, new Apple());
        writeExact(fruit, new Apple());
    }
    static <T> void writeWithWildcard(List<? super T> list, T item) {
        list.add(item)
    }
    static void f2() {
        writeWithWildcard(apples, new Apple());
        writeWithWildcard(fruit, new Apple());
    }
    public static void main(String[] args) {
        f1(); f2();
    }
}

与此相类似大家可今后容器里面添英镑素了,不过选取super的流弊是今后不能get容器里面包车型客车因素了,原因很简短,我们一而再从编写翻译器的角度思索这些难题,对于List<? super Apple> list,它能够有上面二种意义:

List<? super Apple> list = new ArrayList<Apple>();
List<? super Apple> list = new ArrayList<Fruit>();
List<? super Apple> list = new ArrayList<Object>();

当我们品尝通过list来get四个Apple的时候,大概会get获得四个Fruit,这一个Fruit能够是Orange等别的品类的Fruit。

据说上边的例子,大家能够计算出一条规律,”Producer Extends, Consumer
Super”:

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

编写翻译器做完相应的体系检查之后,实际上到了运转时期上边这段代码实际中将转变到:

public class Node {
    private Object data;
    private Node next;
    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }
    public Object getData() { return data; }
    // ...
}

那意味不管大家注脚Node<String>还是Node<Integer>,到了运转时期,JVM统统视为Node<Object>。有未有哪些艺术可以解决那个难题呢?那就须要我们团结再一次安装bounds了,将方面的代码改正成上边那样:

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

与此相类似编写翻译器就能将T现身的地点替换到Comparable而不再是私下认可的Object了:

public class Node {
    private Comparable data;
    private Node next;
    public Node(Comparable data, Node next) {
        this.data = data;
        this.next = next;
    }
    public Comparable getData() { return data; }
    // ...
}

地点的概念恐怕依然相比好明白,但实则泛型擦除带给的主题材料远远不独有这一个,接下去大家系统地来看一下类型擦除所带给的片段主题材料,某个题目在C++的泛型中或许不会凌驾,但是在Java中却须要非常当心。

问题一

在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.

对此地点这段代码依旧很好明白,字符串数组不能够寄放整型成分,何况这么的谬误往往要等到代码运营的时候本领窥见,编写翻译器是回天乏术甄别的。接下来我们再来看一下假使Java扶植泛型数组的始建会现身什么样后果:

Object[] stringLists = new List<String>[];  // compiler error, but pretend it's allowed
stringLists[0] = new ArrayList<String>();   // OK
// An ArrayStoreException should be thrown, but the runtime can't detect it.
stringLists[1] = new ArrayList<Integer>();

一经我们支撑泛型数组的创办,由于运营时代类型音讯已经被擦除,JVM实际上根本就不清楚new ArrayList<String>()new ArrayList<Integer>()的界别。形似那样的怪诞就算现身才实际的施用项景中,将不胜难以发掘。

要是您对地方那或多或少还抱有疑虑的话,能够尝试运维上面这段代码:

public class ErasedTypeEquivalence {
    public static void main(String[] args) {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        System.out.println(c1 == c2); // true
    }
}

问题二

持续复用大家地点的Node的类,对于泛型代码,Java编写翻译器实际上还有大概会暗暗帮我们贯彻贰个Bridge
method。

public class Node<T> {
    public T data;
    public Node(T data) { this.data = data; }
    public void setData(T data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}
public class MyNode extends Node<Integer> {
    public MyNode(Integer data) { super(data); }
    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

看完下面的解析今后,你或者会感到在档次擦除后,编写翻译器会将Node和MyNode形成下边这样:

public class Node {
    public Object data;
    public Node(Object data) { this.data = data; }
    public void setData(Object data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}
public class MyNode extends Node {
    public MyNode(Integer data) { super(data); }
    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

并非这样的,咱们先来看一下底下这段代码,这段代码运转的时候会抛出ClassCastException老大,提示String不可能转变到Integer:

MyNode mn = new MyNode(5);
Node n = mn; // A raw type - compiler throws an unchecked warning
n.setData("Hello"); // Causes a ClassCastException to be thrown.
// Integer x = mn.data;

固然依据大家地点生成的代码,运营到第3行的时候不应有报错(注意本身注释掉了第4行卡塔尔(قطر‎,因为MyNode中不设有setData(String data)方法,所以只可以调用父类Node的setData(Object data)艺术,既然那样位置的第3行代码不应有报错,因为String当然能够调换来Object了,那ClassCastException到底是怎么抛出的?

骨子里Java编写翻译器对上边代码自动还做了二个甩卖:

class MyNode extends Node {
    // Bridge method generated by the compiler
    public void setData(Object data) {
        setData((Integer) data);
    }
    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
    // ...
}

那也正是干吗上面会报错的因由了,setData((Integer) data);的时候String不大概转变来Integer。所以地点第2行编写翻译器提醒unchecked warning的时候,大家不可能选择忽视,不然要等到运转时期技巧开掘卓殊。如若大家一开头增添Node<Integer> n = mn就好了,那样编写翻译器就能够提前帮大家开采错误。

问题三

正如大家地方提到的,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);

骨子里对于地点那个难点,还足以采用Factory和Template二种设计方式焚林而猎,感兴趣的情人无妨去看一下Thinking
in Java中第15章中有关Creating instance of
types(意大利共和国语版第664页卡塔尔国的上课,这里大家就不深入了。

问题四

我们不能对泛型代码直接利用instanceof关键字,因为Java编写翻译器在变化多端代码的时候会擦除具有相关泛型的类型音讯,正如大家地点表明过的JVM在运维时期不可能识别出ArrayList<Integer>ArrayList<String>的里边的界别:

public static <E> void rtti(List<E> list) {
    if (list instanceof ArrayList<Integer>) {  // compile-time error
        // ...
    }
}
=> { ArrayList<Integer>, ArrayList<String>, LinkedList<Character>, ... }

和地点相符,大家能够利用通配符重新恢复生机设置bounds来肃清那么些标题:

public static void rtti(List<?> list) {
    if (list instanceof ArrayList<?>) {  // OK; instanceof requires a reifiable type
        // ...
    }
}

发表评论

电子邮件地址不会被公开。 必填项已用*标注