在泛型出现以前，类和方法只能接受具体的类型。假设我们自己实现一个简单的ArrayList，用来持有类A的实例，它可能是这样子的：
class A {}
class ArrayListA {
private int size = 0;
private A[] array = new A[100];
public void add(A a) {
array[size++] = a;
}
public A get(int index) {
return array[index];
}
}
现在如果需要一个ArrayList来持有类B的实例，由于没有泛型，那只能把同样的代码再写一遍，并将其中的A全部换成B。难道我们要为每一个类都写一个ArrayList吗，显然是不可能的。在泛型出现以前，jdk的ArrayList使用的方法是用Object作为类型参数，这样使用者需要自己做转型，就像下面这样：
public class GenericLearn {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();
arrayList.add("aaa");
String str = (String) arrayList.get(0);
}
}
这样的向下转型，既不方便，也不安全。有没有一种办法，能让类型作为一种可选参数，使得一套代码能复用于多个类，且不需要自己做转型等动作，这便是泛型要解决的问题。
泛型的使用
1. 泛型类
class Holder<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
public void print() {
System.out.println(t);
}
}
上面是一个简单的泛型类，用一个<>来指明参数化类型。现在我们在使用Holder类时就可以指明类型，一旦类型被确定，它就不能用于其他类：
Holder<String> holder = new Holder<>();
// 编译错误
holder.setT(1);
2. 泛型接口
interface Handler<T> {
void handle(T t);
}
class StringHandler implements Handler<String> {
@Override
public void handle(String s) {
// doNothing
}
}
泛型用于接口和用于类的方式差不多。
3. 泛型方法
泛型也可以直接用于方法：
class BatchUtil {
public static <T> void batchExec(List<T> list, int batchSize, Consumer<List<T>> action) {
for (int i = 0; i < list.size(); i += batchSize) {
int endIndex = i + batchSize > list.size() ? list.size() : i + batchSize;
List<T> tempList = list.subList(i, endIndex);
action.accept(tempList);
}
}
}
以上方法定义了一个批量操作的工具类，你可以像这样使用它：
public class GenericLearn {
public static void main(String[] args) {
List<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
BatchUtil.batchExec(list, 3, System.out::println);
}
}
输出：
[1, 2, 3]
[4, 5, 6]
[7]
4. 泛型边界
利用extends关键字，可以为泛型参数限定上边界。
public class GenericLearn {
public static void main(String[] args) {
Holder<A> holder1 = new Holder<>();
Holder<B> holder2 = new Holder<>();
// 编译错误
Holder<String> holder3 = new Holder<>();
}
}
class Holder<T extends A> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
class A {}
class B extends A{}
限定了边界后，泛型的类型就只能是指定类型及其子类。
5. 通配符
上面介绍的泛型类、接口、方法等都是如何定义泛型，至于使用泛型，最通常的就是指定泛型参数，如List<String>，指定了泛型参数为String。但是有时候我们会碰到这样的情况：
public class GenericLearn {
public static void main(String[] args) {
List<A> listA = new ArrayList<>();
List<B> listB = new ArrayList<>();
print(listA);
// 编译错误
print(listB);
}
public static void print(List<A> list) {
for (A a : list) {
System.out.println(a);
}
}
}
class A {}
class B extends A{}
方法接受参数List<A>，却无法将List<B>作为入参，这是因为虽然B可以向上转型为A，List<B>却无法向上转型为List<A>，为了解决这一问题，引入了通配符。
public static void print(List<? extends A> list) {
for (A a : list) {
System.out.println(a);
}
}
将方法改写为这样后，可以编译运行。但是由此也会带来一个副作用：
public static void print(List<? extends A> list) {
for (A a : list) {
System.out.println(a);
}
// 编译错误
list.add(new A());
list.add(new B());
list.add(new Object());
}
用了通配符后，无法对List进行add操作，这是因为List的add方法，其参数是泛型类，而通配符仅仅指定了泛型类的上界，因此任何以泛型类为入参的方法都无法使用。这是可以理解的，因为假如我们传入的是List<B>，那就不能往其中加入A的实例。
这是用通配符指定上界的情况，通配符也可以指定下界，还是以List为例：
public static void main(String[] args) {
List<? super B> list = new ArrayList<>();
list.add(new B());
Object obj = list.get(0);
// 编译错误
list.add(new A());
list.add(new Object());
B b = list.get(0);
A a = list.get(0);
}
用通配符指定下界后，可以执行add操作，但是只可以add类B的实例，因为我们不知道List持有的具体类型是什么，只知道它是B或其超类，在这样的条件下，只有往其中加入类B的实例是安全的，并且从其中拿到的对象只能当作Object来使用。
通配符也可以不指定边界，称为无界通配符，以List为例，对List<?>，不能执行add操作，从中取出的对象只能当作Object来使用。
对于通配符的使用有一个PECS原则(Producer Extends, Consumer Super)，即如果将泛型类作为生产者使用，例如使用List的get方法，则用上界通配符；如果将泛型类作为消费者使用，例如使用List的add方法，则用下界通配符。
泛型的实现原理
很多人把Java的泛型称为伪泛型，因为Java的泛型只是编译期的泛型，一旦编译成字节码，泛型就被擦除了，即在Java中使用泛型，我们无法在运行期知道泛型的类型，因此像下面这样的操作是不行的。
class Holder<T> {
// 编译错误
private T t = new T();
private T[] array = new T[0];
private Class<T> clazz = T.class;
}
因为在jvm运行程序时，类Holder是不带有泛型类T的具体类型的，所以任何需要具体类型的操作，比如实例化对象等，都无法进行。
为了直观的理解泛型擦除，我们可以看一下Holder的字节码：
class Holder {
// access flags 0x2
// signature TT;
// declaration: T
private Ljava/lang/Object; t
@groovyx.ast.bytecode.Bytecode
void <init>() {
aload 0
INVOKESPECIAL java/lang/Object.<init> ()V
return
}
@groovyx.ast.bytecode.Bytecode
public Object getT() {
aload 0
getfield 'Holder.t','Ljava/lang/Object;'
areturn
}
@groovyx.ast.bytecode.Bytecode
public void setT(Object a) {
aload 0
aload 1
putfield 'Holder.t','Ljava/lang/Object;'
return
}
}
可以看到一旦编译成字节码，泛型将被取代为Object。比较一下直接使用Object类和使用泛型的区别：
public class GenericLearn {
public static void main(String[] args) {
Holder holder = new Holder();
holder.setT("abc");
String str = (String) holder.getT();
}
}
class Holder {
private Object t;
public Object getT() {
return t;
}
public void setT(String t) {
this.t = t;
}
}
@groovyx.ast.bytecode.Bytecode
public static void main(String[] a) {
_new 'Holder'
dup
INVOKESPECIAL Holder.<init> ()V
astore 1
aload 1
ldc "abc"
INVOKEVIRTUAL Holder.setT (Ljava/lang/String;)V
aload 1
INVOKEVIRTUAL Holder.getT ()Ljava/lang/Object;
checkcast 'java/lang/String'
astore 2
return
}
下面将Holder加入泛型：
public class GenericLearn {
public static void main(String[] args) {
Holder<String> holder = new Holder<>();
holder.setT("abc");
String str = holder.getT();
}
}
class Holder<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
@groovyx.ast.bytecode.Bytecode
public static void main(String[] a) {
_new 'Holder'
dup
INVOKESPECIAL Holder.<init> ()V
astore 1
aload 1
ldc "abc"
INVOKEVIRTUAL Holder.setT (Ljava/lang/Object;)V
aload 1
INVOKEVIRTUAL Holder.getT ()Ljava/lang/Object;
checkcast 'java/lang/String'
astore 2
return
}
可以看到，两段代码的字节码基本是完全一样的，注意字节码中的checkcast，在不使用泛型时，我们需要将Object手动转型成String，而在使用泛型后，我们不需要自己转型，但实际上我们get到的对象仍然是Object类型的，只不过编译器会自动帮我们加入这个转型动作。
再来看一下使用泛型上界的情况：
class Holder<T extends A> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
class A {}
class Holder {
// access flags 0x2
// signature TT;
// declaration: T
private LA; t
@groovyx.ast.bytecode.Bytecode
void <init>() {
aload 0
INVOKESPECIAL java/lang/Object.<init> ()V
return
}
@groovyx.ast.bytecode.Bytecode
public A getT() {
aload 0
getfield 'Holder.t','LA;'
areturn
}
@groovyx.ast.bytecode.Bytecode
public void setT(A a) {
aload 0
aload 1
putfield 'Holder.t','LA;'
return
}
}
在有了泛型上界后，泛型将被擦除成定义的上界。
现在可以对Java的泛型做一个总结：Java的泛型只存在于编译期，一旦编译成字节码，泛型将被擦除。泛型的作用在于在编译阶段保证我们使用了正确的类型，并且由编译器帮我们加入转型动作，使得转型是不需要关心且安全的。
Java之所以用擦除来实现泛型，是因为Java是在1.5引入的泛型，为了兼容性，即以前没有泛型的程序能运行在新一代的jvm上，且让开发者可以以自己的进度将代码加入泛型特性，而选择了擦除这一办法。具体可以参考《Java编程思想》的泛型章节或知乎上的这篇回答：https://www.zhihu.com/question/28665443/answer/118148143
