什么是泛型？

泛型是指通用的数据类型，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。泛型在Java中的应用主要有两种：对集合对象进行类型安全检查和编写通用Java程序（Java框架）。

泛型的的使用

在介绍泛型在Java中的应用之前，先简单介绍一下泛型是如何使用的。泛型被使用最多的地方是泛型化集合类（集合类包括List、Set、Map等类及其实现类）。使用泛型来声明集合对象时，就规定了集合中元素的数据类型。举个例子，如果要声明一个元素数据类型为String的ArrayList数组，语法为：

List<String> list = new ArrayList<String>();

泛型化集合类的语法为：

集合类<泛型类型> 集合对象名 = new 集合类的实现类<泛型类型>();

注意一下，泛型是JDK1.5（即JDK5）中的新特性，现在的Java教程大部分都是采JDK1.5或者更新的版本，因此在介绍实例化集合类的时候就是采用的上面的声明语法 ，实际上这就运用了泛型。
此外，在泛型化集合类的语法代码中，前后的两个泛型类型必须一致，如下图：

泛型类型不匹配

即使Number是Integer的父类，仍然不允许这样声明。

类型安全检查

前面说过泛型是Java1.5的新特性，那么在Java1.5之前，由于没有泛型，因此可以向集合添加任何数据类型的元素，另外，从集合中取出元素 时，数据类型丢失，这时必须要使用与数据类型相关的方法，进行强制类型转换。声明集合对象的语法十分简单，为：

集合类 集合对象名 = new 集合类的实现类();

举个例子，先声明一个ArrayList数组，再向里面添加不同数据类型的元素，然后遍历这个数组，打印每一个元素，因此代码为：

public class GenericTest {
    @Test
    public void demo1() {
        List list = new ArrayList();
        list.add("abc");
        list.add(123);
        for (int i = 0; i < list.size(); i++) {
        Object o = list.get(i);
        String s = (String) o;
        System.out.println(s);
        }
    }
}

由于没有泛型，数组中每一个元素的数据类型都为Object，所以为了输出abc需要强制将Object型转换成String类型，然而并不是每一个元素都是以String型保存在数组中的。用JUnit进行单体测试，很显然程序会报错：

数据类型报错

原因很简单，123不是以String型保存在数组中的，就无法强制转换为String型，如果想要正确地遍历数组并输出，就只能根据元素保存在数组中的数据类型一个个地进行强制类型转换，如果数组中的元素很多，这样做就会极大地降低效率。
另外，当我们用最原始的方法进行Java编译时，如果不使用泛型，就会出现问题。将上面的代码改写一下：

 public class GenericTest {
    public static void demo1() {
        List list = new ArrayList();
        list.add("abc");
        list.add(123);
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            String s = (String) o;
            System.out.println(s);
        }
     }
     public static void main(String[] args) {
        GenericTest.demo1();
      }
}

进行编译：

编译报错

在文件名前加上-Xlint:unchecked，再次编译：

再次编译成功

此时编译是成功的，因为泛型只是进行类型安全检查，这里相当于忽略类型安全检查。
再把上面的代码改成使用泛型，并且只向数组中添加泛型类型的元素，然后遍历、打印输出：

public class GenericTest {
    public static void demo1() {
        List<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("def");
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            String s = (String) o;
            System.out.println(s);
        }
    }
   public static void main(String[] args) {
        GenericTest.demo1();
    }
}

再编译：

编译

就不会出现类型安全警告了。
需要注意的是，泛型是提供给javac编译器使用的，它用于限定集合的输入类型，让编译器在源代码级别上，阻止向集合输入非法数据的行为。但编译器编译完带泛型的Java程序后，生成的class文件将不会含有泛型信息，使程序运行效率不受影响，这个过程称之为“擦除”。
打开刚才编译生成的class文件就会发现有这么一行 ：

class文件代码

这一行关于数组的代码中并没有出现泛型信息，因为它在Java程序编译完成后被擦除了。
实际上泛型对于List类、Set类和Map类都是生效的，这里只演示一种情况，其余几种情况不再赘述。

编写通用Java程序

先举个例子，现在有两个数组，一个数组的元素全部为int型，另一个则全部为String型，如果需要对两个数组分别进行交换首尾元素位置的操作，最简单方法就是写两个方法对两个数组分别进行操作：

@Test
public void demo2(){//这个方法传递数组引用地址，因此不需要返回值，下面的方法同理
    int[] arr1 = new int[]{1, 2, 3, 4, 5};
    changePosition1(arr1, 0, arr1.length - 1); 
    System.out.println(Arrays.toString(arr1));
}
public void changePosition1(int[] arr, int index1, int index2){
    int temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp; 
}
@Test
public void demo3(){
    String[] arr2 = new String[]{"aaa", "bbb", "ccc", "ddd", "eee"};
    changePosition2(arr2, 0, arr2.length - 1);
    System.out.println(Arrays.toString(arr2));
}
public void changePosition2(String[] arr, int index1, int index2){
    String temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

再用JUnit进行单体测试：

demo2() 运行效果

demo3()运行效果

两个方法都正确的。
但如果再加一个元素全部为double型的数组，仍然进行同样的操作要怎么做呢？当然可以再写一个类似的方法，修改一下代码就行，但这样会使代码变得冗长，并且降低程序的运行效率，这个时候就可以用到泛型。原理很简单，由于这两个方法的实现中只是数据类型不同，就可以用泛型类型代替int型和String型甚至其它的数据类型，从而写成一个对任何数据类型都通用的方法。
定义泛型方法时，必须在方法的返回值之前进行泛型类型声明，语法为：

权限修饰符 <泛型类型> 返回值类型 方法名(参数列表){}

将上面的两个方法利用泛型合并成一个方法，代码为：

@Test
public void demo4(){
    Integer[] arr1 = new Integer[]{1, 2, 3, 4, 5};//泛型类型必须为对象类型而不能为原始类型
    changePosition(arr1, 0, arr1.length - 1);
    System.out.println(Arrays.toString(arr1));
    String[] arr2 = new String[] {"aaa", "bbb", "ccc", "ddd", "eee"};
    changePosition(arr2, 0, arr2.length - 1);
    System.out.println(Arrays.toString(arr2));
}
public <T> void changePosition(T[] arr, int index1, int index2){//这里的T即为泛型类型，参数列表中的数组类型也要修改
    T temp = arr[index1];
    arr[index1] = arr[index2];
    arr[index2] = temp;
}

用JUnit进行单体测试：

demo4()运行效果

结果仍然正确。
定义泛型的方法只对当前方法有效，也可以对类使用泛型。如果对一个类使用泛型，那么这个类中的所有方法都可以使用泛型。定义泛型的类语法为：

权限修饰符 class 类型<泛型类型>{}

还是用刚才的例子，这次用定义泛型类的方法完成交换元素位置的操作。首先要定义一个泛型类，并在类中定义具体的方法实现：

public class GenericUtils<T>{//这里的T为泛型类型
    public void changePosition(T[] arr, int index1, int index2){
        T temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
    }
}

再创建这个泛型类的数组对象，并调用类中的方法：

@Test
public void demo5(){
    GenericUtils<Integer> genericUtils1 = new GenericUtils<Integer>();
    GenericUtils<String> genericUtils2 = new GenericUtils<String>();
    Integer[] arr1 = new Integer[] {1, 2, 3, 4, 5};
    genericUtils1.changePosition(arr1, 0, arr1.length - 1);
    System.out.println(Arrays.toString(arr1));
    String[] arr2 = new String[] {"aaa", "bbb", "ccc", "ddd", "eee"};
    genericUtils2.changePosition(arr2, 0, arr2.length - 1);
    System.out.println(Arrays.toString(arr2));
}

用JUnit进行单体测试：

demo5()运行效果

结果依然是正确的。
需要注意的是，泛型的类不对类中的static方法生效，static方法必须重新定义泛型。另外，虽然泛型类型可以使用任意大写字母，但建议使用有意义的字母，一般使用T、E、K、V，其中T对应Template（模板），E对应Element（元素），K对应Key（键），V对应Vaule（值）。