【JavaSE】泛型

Java泛型

---

2019-07-05  22:00:24  by冲冲

1. 泛型的引例

List list = new ArrayList();
list.add(1022);        //向集合中添加一个 Integer 类型的数据
list.add("Yadiel");    //向集合中添加一个 String 类型的数据

//遍历list元素
for(int i = 0 ; i < list.size() ; i++){
    Object obj = list.get(i);  //注意这里每个类型都是 Object
    System.out.println(obj);
}
 
//如果遍历的时候就想得到自己想要的数据类型
for(int i = 0 ; i < list.size() ; i++){
    String obj = (String) list.get(i);  //在取 Integer 的时候会报类型转换错误
    System.out.println(obj);
}

 报错信息：

意思是 集合中第二个数据是 Integer，但是我们取出来的时候将其转换为 String 了，所以报错。

解决方案：

① 我们在遍历的时候，根据每个数据的类型判断，然后进行强转。缺陷是，如果数据成千上万，该方案不可取。

② 在往集合中加入数据的时候，就做好限制，比如这个集合只能添加 String 类型的，下一个集合只能添加 Integer 类型的（就像数组一样规定元素类型必须相同），那么在取数据时，由于前面已经限制了该集合的数据类型，那么就很好强转了。这第二种解决办法，也就是我们这篇文章讲的 泛型 。

2. 泛型的概念

泛型是Java SE1.5的新特性。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

3. 泛型的语法

（1）引例的解决

List<String> list = new ArrayList<String>();
//list.add(1022);  //向集合中添加一个 Integer 类型的数据时，编译器会报错
list.add("Aoa");   //向集合中添加一个 String 类型的数据
list.add("Loa");   //向集合中添加一个 String 类型的数据
 
//如果我们遍历的时候就想得到自己想要的数据类型
for(int i = 0 ; i < list.size() ; i++){
    String obj = list.get(i);  //这里就不需要强转了，前面添加的是什么类型，这里获取的就是什么类型
    System.out.println(obj);
}

（2）泛型只在编译阶段有效

List<String> list1 = new ArrayList<String>();
List list2 = new ArrayList();
Class c1 = list1.getClass();
Class c2 = list2.getClass();
System.out.println(c1==c2); //true

由于反射是在运行时阶段，c1==c2为 true，说明编译之后的 class 文件中是不包含泛型信息。

结论：Java 泛型只在编译阶段有效，即在编译过程中，程序会正确的检验泛型结果。而编译成功后，class 文件是不包含任何泛型信息的。

（3）泛型类

在类名后面添加 类型参数 的声明部分，其他跟非泛型类完全一样。

泛型类的类型参数声明部分，可以包含一个或多个类型参数，参数间用逗号隔开。

public class Box<T> {
  private T t;
  public void add(T t) {
    this.t = t;
  }
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(1022));
    stringBox.add(new String("肥猪"));
 
    System.out.println("整型值为 :"+ integerBox.get());
    System.out.println("字符串为 :"+ stringBox.get());
  }
}

输出结果：

整型值为 :1022
字符串为 :肥猪

（4）泛型方法

应用场景：假如需要写一个排序方法，能够对整型数组、字符串数组甚至其他任何类型的数组进行排序，该如何实现？答案是泛型。

定义泛型方法的规则：

① 所有泛型方法声明，都有一个 类型参数 的声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。

② 每一个 类型参数 声明部分可以包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。

③ 类型参数 能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。

④ 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char等）。

public class GenericMethodTest {    //演示如何使用泛型方法打印不同字符串的元素
    // 泛型方法 printArray
    public static <E> void printArray(E[] inputArray) {
        // 输出数组元素
        for (E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }

    public static void main(String args[]) {
        // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

        System.out.println("整型数组元素为:");
        printArray(intArray); // 传递一个整型数组

        System.out.println("
双精度型数组元素为:");
        printArray(doubleArray); // 传递一个双精度型数组

        System.out.println("
字符型数组元素为:");
        printArray(charArray); // 传递一个字符型数组
    }
}

输出结果：

整型数组元素为:
1 2 3 4 5 

双精度型数组元素为:
1.1 2.2 3.3 4.4 

字符型数组元素为:
H E L L O 

（5）类型通配符?

① 类型通配符 通常使用 ? 代替具体的类型参数。例如 List<?> 在逻辑上是 List<String>，List<Integer> 等所有List<具体类型实参>的父类。

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("yadiel");
        age.add(18);
        number.add(999);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}

输出结果：

data :yadiel
data :18
data :999

② 类型通配符的上限和下限

上限：<? extends T> 表示该通配符所代表的类型是 T类型 或者 T类型的子类。

下限：<? super T>  表示该通配符所代表的类型是 T类型 或者 T类型的父类。

import java.util.*;
 
public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("yadiel");
        age.add(18);
        number.add(999);
 
        //getUperNumber(name);//String类型表示Number类型的子类，报错
        getUperNumber(age);   //输出18
        getUperNumber(number);//输出999
       
   }
   
   public static void getUperNumber(List<? extends Number> data) {
          System.out.println("data :" + data.get(0));
       }
}

设计泛型方法，返回三个可比较对象的最大值。

public class MaximumTest
{
   // 比较三个值并返回最大值
   public static <T extends Comparable<T>> T maximum(T x, T y, T z)
   {                     
      T max = x; // 假设x是初始最大值
      if ( y.compareTo( max ) > 0 ){
         max = y; //y 更大
      }
      if ( z.compareTo( max ) > 0 ){
         max = z; // 现在 z 更大           
      }
      return max; // 返回最大对象
   }
   public static void main( String args[] )
   {
      System.out.printf( "%d, %d 和 %d 中最大的数为 %d

",
                   3, 4, 5, maximum( 3, 4, 5 ) );
 
      System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f

",
                   6.6, 8.8, 7.7, maximum( 6.6, 8.8, 7.7 ) );
 
      System.out.printf( "%s, %s 和 %s 中最大的数为 %s
","pear",
         "apple", "orange", maximum( "pear", "apple", "orange" ) );
   }
}

输出结果：

3, 4 和 5 中最大的数为 5

6.6, 8.8 和 7.7 中最大的数为 8.8

pear, apple 和 orange 中最大的数为 pear

4. 注意事项

① 不能用基本类型来定义泛型，如 int、float。

List<int> list = new ArrayList<int>(); //不能用 int 这样的基本类型定义泛型

因为集合中只能存放引用类型的数据，即使你存入基本类型，Java还是会通过自动拆箱和自动装箱机制将其转换为引用类型。

② 如果使用 ？ 接收泛型对象时，则不能设置被泛型指定的内容。

List<?> list = new ArrayList<>();
list.add("aa");  //错误，无法设置

③ 泛型方法的定义与其所在的类是否是 泛型类 是没有任何关系的，所在的类可以是泛型类，也可以不是泛型类。

④ 泛型类没有继承关系，即 String 为 Object 类的子类，则 List<String> 是 List<Object> 的子类这句话是错误的。

正确：List<String>==List<Object>。 原因：泛型只是规定了List的元素类型，如果不符合，会在编译阶段报错。在运行阶段，无论List的元素是什么类型，List的类型都属于List。

假设上面那句话是正确的，那么由于泛型的产生机制就是放什么类型的数据进去，取出来的就是什么类型，而不用进行类型转换。
这里把 String 类型的数据放入Object 类的泛型集合中，那么取出来的应该就是 String 类的数据，而实际上取出来的是 Object 类的数据，这与泛型的产生机制相违背，故不成立！

参考：

https://www.cnblogs.com/ysocean/p/6826525.html

https://www.runoob.com/java/java-generics.html