【从零到Offer】- 泛型

泛型是个啥

​ Java 泛型是 JDK 5 中引入的一个新特性，其提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

​ 通过将数据类型参数化，泛型给JAVA代码带来了不少的便利性。因此泛型也成为了许多框架代码中的常客，如日常使用的ArrayList、LinkedList等，其实都是泛型的延伸造化。为了更好的利用好泛型，我们有必要了解一下泛型的便利之处。

泛型用途

代码复用

​ 在引用泛型之前，针对相似逻辑但不同类型对象的转换逻辑，我们可能需要编写多套代码实现。

public Map<String,Sword> transferSword(List<Sword> list){Map<String,Sword> map = new HashMap<>();for (Sword v : list) {String desc = v.getDesc();map.put(desc, v);}return map;
}
public Map<String,Staff> transferStaff(List<Staff> list){Map<String,Staff> map = new HashMap<>();for (Staff v : list) {String desc = v.getDesc();map.put(desc, v);}return map;
}

​ 通过结合上函数式编程，我们就可以将转换的逻辑抽象出来，不再受限于类型的问题。从而实现代码的最大程度的复用。

public <K,V> Map<K,V> transfer(List<V> list, Function<V,K> function){Map<K,V> map = new HashMap<>();for (V v : list) {K apply = function.apply(v);map.put(apply, v);}return map;
} 
public Map<String,Staff> transferStaff(List<Staff> list){return transfer(list, Staff::getDesc);
}
public Map<String,Sword> transferSword(List<Sword> list){return transfer(list, Sword::getDesc);
}

确保类型安全

​ 在没有泛型前，如果我们想要实现参数化数据类型的效果，往往需要把相对应的参数定义为Object基类。以日常我们使用的数组为例子，数据类型参数化后的结果如下所示：

​ 然而，这样的设计其实是存在极大风险的，相当于一个数组内可能存在不同类型的数据。如果在取出的时候执行了强制转换，那么此时就可能出现ClassCastException。

​ 而如果通过泛型定义，编译器就可以在添加元素的时候对加入的类型做判断。从而避免一些取值时候的不安全问题的发生。

消除强制转换

​ 使用Object实现的基类数组还存在一个比较“恶心”的问题，每次取出数据的时候，都需要对取出的对象做强制转换的逻辑，十分不优雅。

    List<Object> arrays = new ArrayList<>();arrays.add("");String a = (String) arrays.get(0);

​ 而采用了泛型后，编译器会自动转换泛型对象的数据格式，从而避免出现需要多次强制转换的情况。

    List<String> arrays = new ArrayList<>();arrays.add("");String a = arrays.get(0);

泛型的用法

​ 使用泛型的方法主要包括两类：泛型类/接口、泛型方法

泛型类/接口

​ 泛型类的使用方法主要通过类后设置类型参数变量，具体的语法如下所示：

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable{......
}

​ 泛型接口同泛型类的使用方法类似，都是在类/接口名后设置类型参数变量的方式：

public interface List<E> extends Collection<E> {...Iterator<E> iterator();...
}

​ 常见的Collection的对象如：ArrayList、LinkedList等，都是采用泛型类的编写方式。而泛型接口与泛型类的不同在于，泛型接口一般都是用于定义顶层的类型用的，如List、Collection这些顶层框架的接口就会使用到这样的编写方式。

泛型方法

​ 泛型方法的使用方式也不复杂。通过在方法返回值前设置类型参数变量即可。如下是ArraysList中的一个泛型方法：

public <T> T[] toArray(T[] a) {if (a.length < size)// Make a new array of a's runtime type, but my contents:return (T[]) Arrays.copyOf(elementData, size, a.getClass());System.arraycopy(elementData, 0, a, 0, size);if (a.length > size)a[size] = null;return a;
}

通配符及上下限

通配符

​ 泛型在使用的过程中，除了通过<T>定义方法和类，在创建对象的时候还可以通过<?>表达泛型的概念，如下是一个实际的例子：

	List<?> arrays;

​ 其中<?>被称为通配符，上述代码的含义是可以匹配任意类型的数组，同List<Object>表达的意思本质上是一致的。

上下限

​ 在实际情况中，通配符还存在一些需要界定范围的情况。比如需要创建一个仅能存放Float、Double、Integer等数字类型的数组，那么最简单的List<?>的方法就不能够满足需求了，需要做更仔细的约束，而这就涉及到上下限了。上下限，顾名思义主要有两个：

• 上限：关键词是extends，其表达的意思是，数组arrays内的类都继承自Number，是Number或者Number的子类。代码如下：

	List<? extends Number> arrays = new ArrayList<>();

• 下限：关键词是super，其表达的意思是，对应的类都是Number或Number的父类。代码如下：

	List<? super Number> arrays = new ArrayList<>();

​ 上下限的概念不复杂，但你可能有疑惑了，这两该咋用呢？别急，让我们来看下面这个例子：

	Integer myInteger = 1;List<? extends Number> arrays1 = new ArrayList<>();arrays1.add(myInterger); // 这个会报错for (Number number : arrays1) {//不会报错......}List<? super Number> arrays2 = new ArrayList<>();arrays1.add(myInterger); // 这个不会报错for (Number number : arrays1) {// 报错......}

上述代码想表达的意思很简单：

​ 在添加的时候，往泛型上限表达的数组arrays1中添加Integer对象报错了，但是在往下限数组arrays2中添加元素的时候却没有报错。在遍历的时候，对arrays1按Number做遍历没有报错，但是对arrays2按Number遍历元素却报错了。这是为什么呢？我们逐一来分析：

添加数据：

​ 在添加数据时，List<Integer>、List<Long>这些类型都可以理解为List<?>或者List<? extends Number>的子类型。这时候如果往List中add数据，编译器没法判断添加的是Integer、Integer还是Double类型。可能会引发类型不一致的问题，这显然和泛型的设计是相悖的。因此Java为了保证类型一致，不允许往泛型上限的数据内添加元素。

​ 然而，对于List<? super Number>来说，其可以理解为List<Number>的父类型，显然List<Number>是可以添加Numer的子类型数据的。

遍历数据：

​ 而在遍历数据的时候，情况就相反了。List<? extends Number>确保了其子类都是继承自Number的。因此可以采用Number对象进行遍历。

​ 但是对于List<? super Number>的数组来说，情况就相反了。因为编译器没法确定所遍历到的对象究竟是Number还是Number的父类，因此只能采用Object对象进行遍历，而并不支持按照Number对象进行遍历的方式。

适用范围

​ 结合上述的讨论，其实还可以得出一个比较重要的点：通配符下限支持添加、通配符上限支持遍历。由此在方法的设计上，可以优先考虑以通配符上线作为入参，以通配符的下限作为方法的出参。下面是一个具体的示例：

public static List<? super Number> transfer(List<? extends Number> numbers){List<? super Number> outputs = new ArrayList<>();for (Number number : numbers) {outputs.add(number);}return outputs;
}

泛型原理

​ 介绍了这么多泛型的定义和用法，那么泛型本身又是如何实现的呢？

​ 相比较C++的泛型实现方式（模版 + 重载），其实JAVA的实现方式很简单，编译器会在编译的时候将使用泛型的类型给擦除掉，都当作默认的Object对象进行处理。这种实现方式也被称为类型擦除。且实际上，编译器并没有根据类型编译出新的代码，JAVA所实现的泛型，也被称为假泛型。

​

泛型翻译

​ 知道了泛型的实现原理以后，我们还需要关注一种情况。这里首先引入泛型类Pair：

public class Pair<T> {private T first;public void setFirst(T first) {this.first = first;}
}

​ 紧接着我们继承该泛型类，并实现一个IntPair对象。IntPair对象中，对原有的set方法做了一次重写。

public class IntPair extends Pair<Integer>{@Overridepublic void setFirst(Integer first) {super.setFirst(first);}
}

​ 但是借由上面对泛型原理的分析，我们不难理解Pair对象的set的方法其实会被翻译成Obejct对象，即如下所示：

public class Pair<Object> {private Object first;public void setFirst(Object first) {this.first = first;}
}

​ 但是我们子类的方法确实实打实的Integer对象呀，这还如何实现重写呢？为了探究这块的实现奥秘，我们有必要对IntPair对象做一次反编译：

public class com.example.demo.service.genericparadigm.IntPair extends com.example.demo.service.genericparadigm.Pair<java.lang.Integer> {public com.example.demo.service.genericparadigm.IntPair();Code:0: aload_01: invokespecial #1                  // Method com/example/demo/service/genericparadigm/Pair."<init>":()V4: returnpublic void setFirst(java.lang.Integer);Code:0: aload_01: aload_12: invokespecial #2                  // Method com/example/demo/service/genericparadigm/Pair.setFirst:(Ljava/lang/Object;)V5: returnpublic void setFirst(java.lang.Object);Code:0: aload_01: aload_12: checkcast     #3                  // class java/lang/Integer5: invokevirtual #4                  // Method setFirst:(Ljava/lang/Integer;)V8: return
}

​ 可以看到，编译器实际上生成了两个方法，一个是预期重写的setFirst(Integer i)方法，而另外一个则是父类的setFirst(Object i)方法。通过上述编译的代码不难看出，java实际上是在setFirst(Integer i)中调用了setFirst(object i)方式实现了代码的重写。这种方式，也被称为桥接方式。通过采用桥接方式，子类就可以成功的对父类中的泛型方法做重载了。

总结

​ 文章从泛型的定义、用法和实现原理各方面介绍了泛型。通过更好的了解泛型，我们才能更合适的用好泛型，提高我们代码的优雅性和效率。

cosmetics Encyclopedia