泛型：是一种类型参数化的机制，是针对利用继承来实现通用的程序设计的各种问题。
泛型的出身：
在没有泛型的时候，也就是在Java1.5之前，我们通常使用集合元素是需要强制转换后才能使用，并且我们是无法阻止非预期的数据类型加入集合的，这样的话在编译器它不会报错，只有在运行期才能报错。这并不是我们所期望的，下面我们看下代码。
package csdn;
import java.util.ArrayList;
/**
* 代码演示
* @author
*
*/
public class JTest {
public static class BeforeGeneric {
static class ArrayList{//泛型之前的通用程序设计
private Object[] elements=new Object[0];
public Object get(int i){
return elements[i];
}
public void add(Object o){
//这里的实现，只是为了演示，不具有任何参考价值
int length=elements.length;
Object[] newElments=new Object[length+1];
for(int i=0;i<length;i++){
newElments[i]=elements[i];
}
newElments[length]=o;
elements=newElments;
}
}
}
public static void main(String[] args){
ArrayList stringValues=new ArrayList();
stringValues.add(1);//可以向数组中添加任何类型的对象
stringValues.add("w");
//问题1——获取值时必须强制转换
String str=(String) stringValues.get(0);
//问题2——上述强制转型编译时不会报错，而运行时会报异常：java.lang.ClassCastException
}
}
这样的程序设计有两个让人头疼的问题：
一：当我们获取其中一个值得时候，我们必须进行强制转换，否则就会在编译时报数字格式异常。
二：假定我们预想的是利用stringValues来存放String集合，因为ArrayList只是维护一个Object引用的数组，我们无法阻止将Integer类型（Object子类等复合数据类型）的数据加入stringValues。然而，当我们使用数据的时候，需要将获取的Object对象转换为我们期望的类型（String），如果向集合中添加了非预期的类型（如Integer），编译时我们不会收到任何的错误提示。
那将会在运行时报出这样的错误：↓↓↓↓↓
这个潜在问题很是致命，因此我们应该想办法在运行前看到错误，让程序在编译时期进行报错，避免程序出现致命的安全问题。
于是，泛型的出现就针对这一问题作出较大的突破。
泛型
泛型也可以通俗的理解为：广泛的数据类型。泛型就是类型的参数化，提供了比较有控制力的：类型参数。就比如ArrayList创建时就需要我们来添加泛型，用一个类型参数指明集合中的元素类型。这就像把集合添加了一个按照数据类型分类的规则。
ArrayList<String> stringValues=new ArrayList<String>();
这样的代码具有更好的可读性，我们一看就知道该集合用来保存String类型的对象，而不是仅仅依赖变量名称来暗示我们期望的类型。
public static void main(String[] args){
ArrayList stringValues=new ArrayList();
stringValues.add(1);//可以向数组中添加字符串类型的数据,这时这句就会出现编译错误
stringValues.add("w");
String str=(String) stringValues.get(0);
}
现在，如果我们向ArrayList<String>添加Integer类型的对象，将会出现编译错误。
The method add(int, String) in the type ArrayList<String> is not applicable for the arguments (int)
at generic.GenericType.main(GenericType.java:8)
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
编译器会自动帮我们检查，避免向集合中插入错误类型的对象，从而使得程序具有更好的安全性。
总之，泛型通过类型参数使得我们的程序具有更好的可读性和安全性。
实现原理
一，擦除
public static void main(String[] args) {
ArrayList<String> liString = new ArrayList<String>();
ArrayList<Integer> liInteger = new ArrayList<Integer>();
System.out.println(liString.getClass()==liInteger.getClass());
//打印的结果为true
}
在这个例子中，我们定义了两个ArrayList数组，不过一个是ArrayList<String>泛型类型，只能存储字符串。一个是ArrayList<Integer>泛型类型，只能存储整型。最后，我们通过arrayString对象和arrayInteger对象的getClass方法获取它们的类信息并比较，发现结果为true。
这是为什么呢，明明我们定义了两种不同的类型？因为，在编译期间，所有的泛型信息都会被擦除，List<Integer>和List<String>类型，在编译后都会变成List类型（原始类型）。Java中的泛型基本上都是在编译器这个层次来实现的，这也是Java的泛型被称为“伪泛型”的原因。
原始类型
原始类型就是泛型类型擦除了泛型信息后，在字节码中真正的类型。无论何时定义一个泛型类型，相应的原始类型都会被自动提供。原始类型的名字就是删去类型参数后的泛型类型的类名。擦除类型变量，并替换为限定类型（T为无限定的类型变量，用Object替换）。
//泛型类型
class Pair<T> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
//泛型类型
class Pair<T> {
private T value;
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
因为在Pair<T>中，T是一个无限定的类型变量，所以用Object替换。如果是Pair<T extends Number>，擦除后，类型变量用Number类型替换。
public class ReflectInGeneric {
public static void main(String[] args) throws IllegalArgumentException,
SecurityException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
ArrayList<Integer> array=new ArrayList<Integer>();
array.add(1);//这样调用add方法只能存储整型数据，因为泛型类型的实例为Integer
array.getClass().getMethod("add", Object.class).invoke(array, "asd");
for (int i=0;i<array.size();i++) {
System.out.println(array.get(i));
}
}
输出：
1
asd
为什么呢？我们在介绍泛型时指出向ArrayList<Integer>中插入String类型的对象，编译时会报错。现在为什么又可以了呢？
我们在程序中定义了一个ArrayList<Integer>泛型类型，如果直接调用add方法，那么只能存储整形的数据。不过当我们利用反射调用add方法的时候，却可以存储字符串。这说明ArrayList<Integer>泛型信息在编译之后被擦除了，只保留了原始类型，类型变量（T）被替换为Object，在运行时，我们可以行其中插入任意类型的对象。
但是，并不推荐以这种方式操作泛型类型，因为这违背了泛型的初衷（减少强制类型转换以及确保类型安全）。当我们从集合中获取元素时，默认会将对象强制转换成泛型参数指定的类型（这里是Integer），如果放入了非法的对象这个强制转换过程就会出现异常。
泛型方法的类型推断
在调用泛型方法的时候，可以指定泛型类型，也可以不指定。
在不指定泛型类型的情况下，泛型类型为该方法中的几种参数类型的共同父类的最小级，直到Object。
在指定泛型类型的时候，该方法中的所有参数类型必须是该泛型类型或者其子类。
public class Test {
public static void main(String[] args) {
/**不指定泛型的时候*/
int i=Test.add(1, 2); //这两个参数都是Integer，所以T替换为Integer类型
Number f=Test.add(1, 1.2);//这两个参数一个是Integer，另一个是Float，所以取同一父类的最小级，为Number
Object o=Test.add(1, "asd");//这两个参数一个是Integer，另一个是String，所以取同一父类的最小级，为Object
/**指定泛型的时候*/
int a=Test.<Integer>add(1, 2);//指定了Integer，所以只能为Integer类型或者其子类
int b=Test.<Integer>add(1, 2.2);//编译错误，指定了Integer，不能为Float
Number c=Test.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float
}
//这是一个简单的泛型方法
public static <T> T add(T x,T y){
return y;
}
}
正确的运转
既然说类型变量会在编译的时候擦除掉，那为什么定义了ArrayList<Integer>泛型类型，而不允许向其中插入String对象呢？不是说泛型变量Integer会在编译时候擦除变为原始类型Object吗，为什么不能存放别的类型呢？既然类型擦除了，如何保证我们只能使用泛型变量限定的类型呢？
java是如何解决这个问题的呢？java编译器是通过先检查代码中泛型的类型，然后再进行类型擦除，再进行编译的。
如下代码为例：
Pair<Integer> pair=new Pair<Integer> ();
pair.setValue(3);
Integer integer=pair.getValue();
System.out.println(integer);
擦除getValue()的返回类型后将返回Object类型，编译器自动插入Integer的强制类型转换。也就是说，编译器把这个方法调用翻译为两条字节码指令：
1、对原始方法Pair.getValue的调用
2、将返回的Object类型强制转换为Integer
此外，存取一个泛型域时，也要插入强制类型转换。因此，我们说Java的泛型是在编译器层次进行实现的，被称为“伪泛型”，相对于C++。
泛型相关面试题：
1. Java中的泛型是什么 ? 使用泛型的好处是什么?
泛型是一种参数化类型的机制。它可以使得代码适用于各种类型，从而编写更加通用的代码，例如集合框架。
泛型是一种编译时类型确认机制。它提供了编译期的类型安全，确保在泛型类型（通常为泛型集合）上只能使用正确类型的对象，避免了在运行时出现ClassCastException。
2、Java的泛型是如何工作的 ? 什么是类型擦除 ?
泛型的正常工作是依赖编译器在编译源码的时候，先进行类型检查，然后进行类型擦除并且在类型参数出现的地方插入强制转换的相关指令实现的。
编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。例如List<String>在运行时仅用一个List类型来表示。为什么要进行擦除呢？这是为了避免类型膨胀。
3. 什么是泛型中的限定通配符和非限定通配符 ?
限定通配符对类型进行了限制。有两种限定通配符，一种是<? extends T>它通过确保类型必须是T的子类来设定类型的上界，另一种是<? super T>它通过确保类型必须是T的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。另一方面<?>表示了非限定通配符，因为<?>可以用任意类型来替代。
4. List<? extends T>和List <? super T>之间有什么区别 ?
这和上一个面试题有联系，有时面试官会用这个问题来评估你对泛型的理解，而不是直接问你什么是限定通配符和非限定通配符。这两个List的声明都是限定通配符的例子，List<? extends T>可以接受任何继承自T的类型的List，而List<? super T>可以接受任何T的父类构成的List。例如List<? extends Number>可以接受List<Integer>或List<Float>。在本段出现的连接中可以找到更多信息。
5. 如何编写一个泛型方法，让它能接受泛型参数并返回泛型类型?
编写泛型方法并不困难，你需要用泛型类型来替代原始类型，比如使用T, E or K,V等被广泛认可的类型占位符。泛型方法的例子请参阅Java集合类框架。最简单的情况下，一个泛型方法可能会像这样:
view plain copy
public V put(K key, V value) {
return cache.put(key, value);
}
6. Java中如何使用泛型编写带有参数的类?
这是上一道面试题的延伸。面试官可能会要求你用泛型编写一个类型安全的类，而不是编写一个泛型方法。关键仍然是使用泛型类型来代替原始类型，而且要使用JDK中采用的标准占位符。
7. 编写一段泛型程序来实现LRU缓存?
对于喜欢Java编程的人来说这相当于是一次练习。给你个提示，LinkedHashMap可以用来实现固定大小的LRU缓存，当LRU缓存已经满了的时候，它会把最老的键值对移出缓存。LinkedHashMap提供了一个称为removeEldestEntry()的方法，该方法会被put()和putAll()调用来删除最老的键值对。
8. 你可以把List<String>传递给一个接受List<Object>参数的方法吗？
对任何一个不太熟悉泛型的人来说，这个Java泛型题目看起来令人疑惑，因为乍看起来String是一种Object，所以List<String>应当可以用在需要List<Object>的地方，但是事实并非如此。真这样做的话会导致编译错误。如果你再深一步考虑，你会发现Java这样做是有意义的，因为List<Object>可以存储任何类型的对象包括String, Integer等等，而List<String>却只能用来存储Strings。
List<Object> objectList;
List<String> stringList;
objectList = stringList; //compilation error incompatible types
9. Array中可以用泛型吗?
这可能是Java泛型面试题中最简单的一个了，当然前提是你要知道Array事实上并不支持泛型，这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array，因为List可以提供编译期的类型安全保证，而Array却不能。
10. 如何阻止Java中的类型未检查的警告?
如果你把泛型和原始类型混合起来使用，例如下列代码，Java 5的javac编译器会产生类型未检查的警告
，例如List<String> rawList = new ArrayList()
注意: Hello.java使用了未检查或称为不安全的操作;
这种警告可以使用@SuppressWarnings("unchecked")注解来屏蔽。
11、Java中List<Object>和原始类型List之间的区别?
原始类型和带参数类型<Object>之间的主要区别是，在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查，通过使用Object作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String或Integer。这道题的考察点在于对泛型中原始类型的正确理解。它们之间的第二点区别是，你可以把任何带参数的泛型类型传递给接受原始类型List的方法，但却不能把List<String>传递给接受List<Object>的方法，因为会产生编译错误。
12、Java中List<?>和List<Object>之间的区别是什么?
这道题跟上一道题看起来很像，实质上却完全不同。List<?> 是一个未知类型的List，而List<Object>其实是任意类型的List。你可以把List<String>, List<Integer>赋值给List<?>，却不能把List<String>赋值给List<Object>。
List<?> listOfAnyType;
List<Object> listOfObject = new ArrayList<Object>();
List<String> listOfString = new ArrayList<String>();
List<Integer> listOfInteger = new ArrayList<Integer>();
listOfAnyType = listOfString; //legal
listOfAnyType = listOfInteger; //legal
listOfObjectType = (List<Object>) listOfString; //compiler error - in-convertible types
13、List<String>和原始类型List之间的区别.
该题类似于“原始类型和带参数类型之间有什么区别”。带参数类型是类型安全的，而且其类型安全是由编译器保证的，但原始类型List却不是类型安全的。你不能把String之外的任何其它类型的Object存入String类型的List中，而你可以把任何类型的对象存入原始List中。使用泛型的带参数类型你不需要进行类型转换，但是对于原始类型，你则需要进行显式的类型转换。
List listOfRawTypes = new ArrayList();
listOfRawTypes.add("abc");
listOfRawTypes.add(123); //编译器允许这样 - 运行时却会出现异常
String item = (String) listOfRawTypes.get(0); //需要显式的类型转换
item = (String) listOfRawTypes.get(1); //抛ClassCastException，因为Integer不能被转换为String
List<String> listOfString = new ArrayList();
listOfString.add("abcd");
listOfString.add(1234); //编译错误，比在运行时抛异常要好
item = listOfString.get(0); //不需要显式的类型转换 - 编译器自动转换