【数据结构】泛型

一、什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。----- 来源《Java编程思想》对泛型的介绍。

泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

二、引出泛型

1、语法

class 泛型类名称<类型形参列表> {
	// 这里可以使用类型参数
}

class ClassName<T1, T2, ..., Tn> {

}

class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
	// 这里可以使用类型参数
}

class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
	// 可以只使用部分类型参数
}

class Message<T> {
    private T message ;
    
    public T getMessage() {
        return message;
    }
    
    public void setMessage(T message) {
        this.message = message;
    }
}

类名后的 <T> 代表占位符，表示当前类是一个泛型类

【规范】：

• 类型形参一般使用一个大写字母表示，常用的名称有：
  E 表示 Element
  K 表示 Key
  V 表示 Value
  N 表示 Number
  T 表示 Type
  S，U，V 等等 - 第二、第三、第四个类型

三、泛型类的使用

1、语法

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

2、示例

MyArray<Integer> list = new MyArray<Integer>();

注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

3、类型推导(Type Inference)

当编译器可以根据上下文推导出类型实参时，可以省略类型实参的填写

MyArray<Integer> list = new MyArray<>(); // 可以推导出实例化需要的类型实参为 Integer

四、泛型的上界

在定义泛型类时，有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

1、语法

class 泛型类名称<类型形参 extends 类型边界> {
	...
}

2、示例

public class MyArray<E extends Number> {
	...
}

MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型

五、泛型方法

定义语法

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) { ... }

示例

public class Util {
	//静态的泛型方法 需要在static后用<>声明泛型类型参数
	public static <E> void swap(E[] array, int i, int j) {
		E t = array[i];
		array[i] = array[j];
		array[j] = t;
	}
}

使用示例-可以类型推导

Integer[] a = { ... };
swap(a, 0, 9);

String[] b = { ... };
swap(b, 0, 9);

使用示例-不使用类型推导

Integer[] a = { ... };
Util.<Integer>swap(a, 0, 9);

String[] b = { ... };
Util.<String>swap(b, 0, 9);

六、通配符

? 用于在泛型的使用，即为通配符

1、通配符的使用

通配符是用来解决泛型无法协变的问题的，协变指的就是如果 Student 是 Person 的子类，那么 List<Student> 也应该是 List<Person> 的子类。但是泛型是不支持这样的父子类关系的。

class Message<T> {
    private T message ;

    public T getMessage() {
        return message;
    }

    public void setMessage(T message) {
        this.message = message;
    }
}

public class Test {

    public static void fun(Message<?> temp){
        //temp.setMessage("cold"); // 不能往里面加元素
        System.out.println(temp.getMessage());
    }

    public static void main(String[] args) {
        Message<String> message1 = new Message() ;
        message1.setMessage("frost");
        fun(message1);

        Message<Integer> message2 = new Message() ;
        message2.setMessage(1);
        fun(message2);
    }
}

以上 Integer 和 String 可以传参，但不能往Message里面写东西。

在 ? 的基础上又产生了两个子通配符：
? extends 类：设置泛型上限
? super 类：设置泛型下限

2、通配符上界

语法：

<? extends 上界>
<? extends Number>//可以传入的实参类型是Number或者Number的子类

class Food {
}

class Fruit extends Food {

}

class Apple extends Fruit {

}

class Banana extends Fruit {

}

class Plate<T> {
    private T plate;

    public T getPlate() {
        return plate;
    }

    public void setPlate(T plate) {
        this.plate = plate;
    }
}

public class Test {
    // 此时使用通配符"?"描述的是它可以接收任意类型，但是由于不确定类型，所以无法修改
    public static void func(Plate<? extends Fruit> temp) {
    	// 此时通配符的上界为Fruit，可以接收的是Fruit和他的子类
        System.out.println(temp.getPlate());
        Fruit fruit = temp.getPlate();

        //temp.setMessage(new Apple());
        //此时无法在fun函数中对temp进行添加元素,因为temp接收的是Fruit和他的子类,
        //此时存储的元素应该是哪个子类无法确定。所以添加会报错！但是可以获取元素。
    }

    public static void main(String[] args) {
        Plate<Apple> plate1 = new Plate<>();
        Plate<Banana> plate2 = new Plate<>();
        func(plate1);
        func(plate2);
    }
}

通配符的上界，不能进行写入数据，只能进行读取数据。

3、通配符下界

语法：

<? super 下界>
<? super Integer>//代表 可以传入的实参的类型是Integer或者Integer的父类类型

class Food {
}

class Fruit extends Food {

}

class Apple extends Fruit {

}

class Banana extends Fruit {

}

class Plate<T> {
    private T plate;

    public T getPlate() {
        return plate;
    }

    public void setPlate(T plate) {
        this.plate = plate;
    }
}

public class Test {
    // 通配符的下界，可以接收的是Fruit和他的父类
    public static void func(Plate<? super Fruit> temp) {
        // 可以修改但不能获取
        temp.setPlate(new Apple());
        temp.setPlate(new Banana());

        //Fruit fruit = (Fruit) temp.getPlate(); // 不能接收，这里无法确定是哪个父类
    }

    public static void main(String[] args) {
        Plate<Food> plate1 = new Plate<>();
        Plate<Fruit> plate2 = new Plate<>();
        func(plate1);
        func(plate2);
    }
}

通配符的下界，不能进行读取数据，只能写入数据。

七、包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

1、基本数据类型和对应的包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Charater
bool	Boolean

2、装箱和拆箱

基本数据类型 —> 包装类类型：装箱（装包）
包装类类型 —> 基本数据类型：拆箱（拆包）

public static void main(String[] args) {
    int i = 10;
    // 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
    Integer ii = Integer.valueOf(i);
    Integer ij = new Integer(i);
    // 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
    int j = ii.intValue();
}

public static void main(String[] args) {
    int i = 10;
    Integer ii = i; // 自动装箱
    Integer ij = (Integer)i; // 自动装箱
    Integer ik = Integer.valueOf(i); // 手动拆箱

    int j = ii; // 自动拆箱
    int k = (int)ii; // 自动拆箱
}

【面试题】

public static void main(String[] args) {
    Integer a = 127;
    Integer b = 127;
    Integer c = 128;
    Integer d = 128;

    System.out.println(a == b);
    System.out.println(c == d);
    System.out.println(a.equals(b));
    System.out.println(c.equals(d));
}

运行结果：

true
false
true
true

【解释】
使用 Integer 自动装箱会调用 valueOf 创建，在valueOf 方法中，low = -128，high = 127，在 [-128，127] 区间内，则会将数放在 cache 数组里，但在区间之外，会 new Integer(i)，所以a == b结果是 false，a.equals(b) 运行结果为 true.