Java中的泛型使用

约定不等于承诺〃 2022-06-15 02:46 125阅读 0赞

Java中的泛型使用  
一、为什么需要泛型  
来看这段简短的代码:

public class Test {
    
    
        public static void main(String[] args) {
            List list = new ArrayList();
            list.add("kang");
            list.add("test");
            list.add(100);
    
    
            for (int i = 0; i < list.size(); i++) {
                String name = (String) list.get(i); // 1
                System.out.println("name:" + name);
            }
        }
    }

上述代码定义了一个List类型的集合，先向其中加入了两个字符串类型的值，随后加入一个Integer类型的值。这是完全允许的，因为此时list默认的类型为Object类型。所以后面循环时我们从集合中取出来的还是Object类型，但是其运行时类型还是当时存入集合时的类型。所以当我们向上转型时，Integer类型是无法转为String类型的。会出现如下异常：“java.lang.ClassCastException”  
  
  
在如上的编码过程中，我们发现主要存在两个问题：  
1、当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，该对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。  
2.因此，当我们取出集合元素时需要人为的强制类型转化到具体的目标类型，且很容易出现“java.lang.ClassCastException”异常。  
那么有没有什么办法可以使集合能够记住集合内元素各类型，且能够达到只要编译时不出现问题，运行时就不会出现“java.lang.ClassCastException”异常呢？答案就是使用泛型。  
  
  
二、什么是泛型？  
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型进行参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。  
来看下上面那个例子采用泛型的写法。

public class Test {
    
    
        public static void main(String[] args) {
     
            List<String> list = new ArrayList<String>();
            list.add("kang");
            list.add("test");
            //list.add(100);   //这里编译器会提示编译错误
    
    
            for (int i = 0; i < list.size(); i++) {
                String name = list.get(i); // 2
                System.out.println("name:" + name);
            }
        }
    }

采用泛型写法后，在如果想加入一个Integer类型的对象时会出现编译错误，通过List<String>，直接限定了list集合中只能含有String类型的元素，从而在取出元素时无须进行强制类型转换，因为此时，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。  
结合上面的泛型定义，我们知道在List<String>中，String是类型实参，也就是说，相应的List接口中肯定含有类型形参。且get()方法的返回结果也直接是此形参类型（也就是对应的传入的类型实参）。下面就来看看List接口的的具体定义：

public interface List<E> extends Collection<E> {
    
    
        int size();
    
    
        boolean isEmpty();
    
    
        boolean contains(Object o);
    
    
        Iterator<E> iterator();
    
    
        Object[] toArray();
    
    
        <T> T[] toArray(T[] a);
    
    
        boolean add(E e);
    
    
        boolean remove(Object o);
    
    
        boolean containsAll(Collection<?> c);
    
    
        boolean addAll(Collection<? extends E> c);
    
    
        boolean addAll(int index, Collection<? extends E> c);
    
    
        boolean removeAll(Collection<?> c);
    
    
        boolean retainAll(Collection<?> c);
    
    
        void clear();
    
    
        boolean equals(Object o);
    
    
        int hashCode();
    
    
        E get(int index);
    
    
        E set(int index, E element);
    
    
        void add(int index, E element);
    
    
        E remove(int index);
    
    
        int indexOf(Object o);
    
    
        int lastIndexOf(Object o);
    
    
        ListIterator<E> listIterator();
    
    
        ListIterator<E> listIterator(int index);
    
    
        List<E> subList(int fromIndex, int toIndex);
    }

我们可以看到，在List接口中采用泛型化定义之后，<E>中的E表示类型形参，可以接收具体的类型实参，并且此接口定义中，凡是出现E的地方均表示相同的接受自外部的类型实参。  
自然的，ArrayList作为List接口的实现类，其定义形式是：

public class ArrayList<E> extends AbstractList<E> 
            implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
        
        public boolean add(E e) {
            ensureCapacityInternal(size + 1);  // Increments modCount!!
            elementData[size++] = e;
            return true;
        }
        
        public E get(int index) {
            rangeCheck(index);
            checkForComodification();
            return ArrayList.this.elementData(offset + index);
        }
        
        //...省略掉其他具体的定义过程
    
    
    }

三、自定义泛型接口、泛型类和泛型方法  
泛型在具体使用时，可以分为泛型接口、泛型类和泛型方法。  
自定义泛型接口、泛型类和泛型方法与上述Java源码中的List、ArrayList类似。如下，我们看一个最简单的泛型类和方法定义：

public class Test {
    
    
        public static void main(String[] args) {
    
    
            Box<String> name = new Box<String>("kang");
            System.out.println("name:" + name.getData());
        }
    
    
    }
    
    
    class Box<T> {
    
    
        private T data;
    
    
        public Box() {
    
    
        }
    
    
        public Box(T data) {
            this.data = data;
        }
    
    
        public T getData() {
            return data;
        }
    
    
    }

在泛型接口、泛型类和泛型方法的定义过程中，我们常见的如T、E、K、V等形式的参数常用于表示泛型形参，由于接收来自外部使用时候传入的类型实参。那么对于不同传入的类型实参，生成的相应对象实例的类型是不是一样的呢？

public class Test {
    
    
        public static void main(String[] args) {
    
    
            Box<String> name = new Box<String>("kang");
            Box<Integer> age = new Box<Integer>(666);
    
    
            System.out.println("name class:" + name.getClass());      // name class:class com.kang.Box
            System.out.println("age class:" + age.getClass());        // age class:class com.kang.Box
            System.out.println(name.getClass() == age.getClass());    // true
    
    
        }
    
    
    }
    class Box<T> {
    
    
        private T data;
    
    
        public Box() {
    
    
        }
    
    
        public Box(T data) {
            this.data = data;
        }
    
    
        public T getData() {
            return data;
        }
    
    
    }

由此，我们发现，在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中为Box），当然，在逻辑上我们可以理解成多个不同的泛型类型。  
究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦除。也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。  
原始类型就是泛型类型擦除了泛型信息后，在字节码中真正的类型。无论何时定义一个泛型类型，相应的原始类型都会被自动提供。原始类型的名字就是删去类型参数后的泛型类型的类名。擦除类型变量，并替换为限定类型（T为无限定的类型变量，用Object替换）。  
定义一个泛型如下：

//泛型类型  
    class Pair<T> {    
        private T value;    
        public T getValue() {    
            return value;    
        }    
        public void setValue(T  value) {    
            this.value = value;    
        }    
    }

相应的原始类型如下：  
//原始类型

class Pair {    
        private Object value;    
        public Object getValue() {    
            return value;    
        }    
        public void setValue(Object  value) {    
            this.value = value;    
        }    
    }

因为在Pair<T>中，T是一个无限定的类型变量，所以用Object替换。如果是Pair<T extends Number>，擦除后，类型变量用Number类型替换。  
因为泛型会被擦除，所以通过反射调用类的方法时情况不同。如下：

public class Test {  
        public static void main(String[] args) throws Exception{    
            ArrayList<Integer> array=new ArrayList<Integer>();    
            array.add(1);//这样调用add方法只能存储整形，因为泛型类型的实例为Integer    
            array.getClass().getMethod("add", Object.class).invoke(array, "kang");    
            for (int i=0;i<array.size();i++) {    
                System.out.println(array.get(i));    
            }    
        }    
    }

输出：  
1  
kang  
为什么呢？我们在程序中定义了一个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;    
        }   
    }

四、类型通配符  
Box<Number>和Box<Integer>实际上都是Box类型，现在需要继续探讨一个问题：在逻辑上，类似于Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型呢？  
  
  
为了弄清这个问题，我们继续看下下面这个例子:

public class Test {
    
    
    	public static void main(String[] args) {
    
    
    		Box<Number> name = new Box<Number>(99);
    		Box<Integer> age = new Box<Integer>(712);
    
    
    		getData(name);
    
    
    		/*
    		 * 下面这条语句报如下编译错误： The method getData(Box<Number>) in the type
    		 * GenericTest is not applicable for the arguments (Box<Integer>)
    		 */
    		// getData(age);//代码1
    
    
    	}
    
    
    	public static void getData(Box<Number> data) {
    		System.out.println("data :" + data.getData());
    	}
    
    
    }

我们发现，在代码1出现了错误提示信息：The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。显然，通过提示信息，我们知道Box<Number>在逻辑上不能视为Box<Integer>的父类。那么，原因何在呢？  
  
  
看如下代码：

public class Test {
    
    
        public static void main(String[] args) {
    
    
            Box<Integer> a = new Box<Integer>(712);
            Box<Number> b = a;  // 1
            Box<Float> f = new Box<Float>(3.14f);
            b.setData(f);        // 2
    
    
        }
    
    
        public static void getData(Box<Number> data) {
            System.out.println("data :" + data.getData());
        }
    
    
    }
    
    
    class Box<T> {
    
    
        private T data;
    
    
        public Box() {
    
    
        }
    
    
        public Box(T data) {
            setData(data);
        }
    
    
        public T getData() {
            return data;
        }
    
    
        public void setData(T data) {
            this.data = data;
        }
    
    
    }

这个例子中，显然//1和//2处肯定会出现错误提示的。在此我们可以使用反证法来进行说明。  
假设Box<Number>在逻辑上可以视为Box<Integer>的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Box<Number>不能视为Box<Integer>的父类。  
那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总不能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box<Integer>和Box<Number>的父类的一个引用类型，由此，类型通配符应运而生。  
类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。

public class Test {
    
    
        public static void main(String[] args) {
    
    
            Box<String> name = new Box<String>("kang");
            Box<Integer> age = new Box<Integer>(666);
            Box<Number> number = new Box<Number>(888);
    
    
            getData(name);
            getData(age);
            getData(number);
        }
    
    
        public static void getData(Box<?> data) {
            System.out.println("data :" + data.getData());
        }
    
    
    }

有时候，我们还可能看到类型通配符上限和类型通配符下限的概念。具体有是怎么样的呢？  
在上面的例子中，如果需要定义一个功能类似于getData()的方法，但对类型实参又有进一步的限制：只能是Number类及其子类。此时，需要用到类型通配符上限。

public class Test {
    
    
        public static void main(String[] args) {
    
    
            Box<String> name = new Box<String>("kang");
            Box<Integer> age = new Box<Integer>(666);
            Box<Number> number = new Box<Number>(888);
    
    
            getData(name);
            getData(age);
            getData(number);
            
            //getUpperNumberData(name); // 1
            getUpperNumberData(age);    // 2
            getUpperNumberData(number); // 3
        }
    
    
        public static void getData(Box<?> data) {
            System.out.println("data :" + data.getData());
        }
        
        public static void getUpperNumberData(Box<? extends Number> data){
            System.out.println("data :" + data.getData());
        }
    
    
    }

此时，显然，在代码//1处调用将出现错误提示，而//2 //3处调用正常。  
类型通配符上限通过形如Box<? extends Number>形式定义，相对应的，类型通配符下限为Box<? super Number>形式，其含义与类型通配符上限正好相反，在此不作过多阐述了。  
  
  
五、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));
        }
    }

六、泛型的相关问题  
1、  
在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
        }
    }

2、  
对于泛型代码，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就好了，这样编译器就可以提前帮我们发现错误。  
  
  
3、  
正如我们上面提到的，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);  
  
  
4、  
我们无法对泛型代码直接使用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
            // ...
        }
    }

5、  
在Java中，像下面形式的引用传递是不允许的：  
ArrayList<String> arrayList1=new ArrayList<Object>();//编译错误  
ArrayList<Object> arrayList1=new ArrayList<String>();//编译错误  
  
  
6、  
泛型类型变量不能是基本数据类型。  
就比如，没有ArrayList<double>，只有ArrayList<Double>。因为当类型擦除后，ArrayList的原始类中的类型变量（T）替换为Object，但Object类型不能存储double值。  
  
  
7、  
泛型类中的静态方法和静态变量不可以使用泛型类所声明的泛型类型参数。

public class Test<T> {      
        public static T one;   //编译错误      
        public static  T show(T one){ //编译错误      
            return null;      
        }      
    }

因为泛型类中的泛型参数的实例化是在定义泛型类型对象（例如ArrayList<Integer>）的时候指定的，而静态变量和静态方法不需要使用对象来调用。对象都没有创建，如何确定这个泛型参数是何种类型，所以当然是错误的。  
但是要注意区分下面的一种情况：

public class Test<T> {      
        public static <T> T show(T one){//这是正确的      
            return null;      
        }      
    }

因为这是一个泛型方法，在泛型方法中使用的T是自己在方法中定义的T，而不是泛型类中的T。  
  
  
七、泛型相关面试题  
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集合类框架。最简单的情况下，一个泛型方法可能会像这样:  
public V put(K key, V value) \{  
return cache.put(key, value);  
\}  
  
  
6. Java中如何使用泛型编写带有参数的类?  
这是上一道面试题的延伸。面试官可能会要求你用泛型编写一个类型安全的类，而不是编写一个泛型方法。关键仍然是使用泛型类型来代替原始类型，而且要使用JDK中采用的标准占位符。  
  
  
7. 编写一段泛型程序来实现LRU缓存?  
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>。

[java] view plain copy
    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中。使用泛型的带参数类型你不需要进行类型转换，但是对于原始类型，你则需要进行显式的类型转换。

[java] view plain copy
    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); //不需要显式的类型转换 - 编译器自动转换