数据结构(Java版)第二期：包装类和泛型

public class Main {
    public static void main(String[] args) {
        int i = 10;
        Integer ii = i;//自动装箱
        Integer ij = (Integer) i;//自动装箱，后面的(Integer)可有可无

        int j = ii;//自动拆箱
        int k = (int)ii;//自动拆箱，后面的(int)可有可无
    }
}

我们可以通过javap-c查看字节码⽂件内容，观察装箱和拆箱的操作。我们可以在IDEA里面装一个jclasslib ByteCode Viewer的插件，然后点击View，再点击Show Bytecode With Jclasslib。我们点到main方法，点击code，就可以看到所对应的字节码文件。

我们来看下面的一段代码，此时的a,b,c,d,e都是引用类型变量。当赋值相同时，结果就是true；当赋值不同时，结果就是false。当赋值超出包装类型的范围时，无论赋值相不相等，结果都是false。

这是因为Integer里面的常量值放在常量池当中，我们进行赋值，相当于在常量池中进行取值，如果超出这个值，那么就是池内与池外的进行比较，结果就是false。

public class Main {
    public static void main(String[] args) {
        Integer a = 127;
        Integer b = 127;
        System.out.println(a == b);//true

        Integer c = 128;
        Integer d = 128;
        System.out.println(c == d);//false

        Integer e = 126;
        System.out.println(a == e);//false
    }
}

二、泛型的概念

很多编程语言都有泛型这样的语法机制。在Java中，写一个类或者是方法，需要声明方法里面的成员或者参数的类型。但也有些情况下，需要一个类或者方法能够多种类型支持。也就是一份代码，支持多种数据类型。

三、引出泛型

3.1. 语法规则

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

class ClassName<T1,T2,……,Tn>{
}

参数列表中要把类中会用的哪些类型列出来，后续使用这个类，创建实例的时候也要同时指定泛型参数的实参。T1,T2相当于类型的形参。

private T[] arrays = new T[];
//这种写法是错误的

因为T要表示任何类型，new T[]的时候就可能会涉及到该类的构造方法，T是什么类型不知道该怎么办？就得先写成Object[]再进行强转。

T[] arrays = (T[]) new Object[];

class MyArray<T>{
    T[] arrays = (T[]) new Object[10];
    public T get(int index){
        return arrays[index];//获取数组的下标
    }
    public void set(int index,T value){
        arrays[index] = value;//对数组进行赋值
    }
}
//上面的T不用再进行强转了

//对方法的实现
public class Main {
    public static void main(String[] args) {
        MyArray<String> array1 = new MyArray<String>();//里面可以存放字符。代码是灰色的，表示可以不写
        MyArray<Integer> array2 = new MyArray<>();//里面可以存放整数
        MyArray array4 = new MyArray();//裸类型，这种写法是不科学的
        MyArray<int> array3 = new MyArray<>();//error: Type argument cannot be of primitive type
    }
}

3.2. 泛型的优点

1.代码重用，一份代码，支持多种类型； 2.自动地进行类型转化，编译过程中会自动触发一些类型检查。

四、类型擦除

4.1. 擦除的机制

Java的泛型，本质上是通过Object类进行编译的。编译器生成代码的时候，自动进行类型转化。比如下面的代码中的get方法，我要对T转化成String类型，编译器从数组中拿到的是一个Object类，然后进行自动转化成String类，返回到调用位置。在set方法里面，set String进来，编译器再自动把String转化成Object。

class MyArray<T>{
    T[] arrays = (T[]) new Object[10];
    public T get(int index){
        return arrays[index];
    }
    public void set(int index,T value){
        arrays[index] = value;
    }
}

下面是一段擦除的代码用例

//擦除前
class MyArray<T>{
    public Object[] arrays = new Object[10];
    public T getPos(int pos){
        return (T)this.arrays[pos];
    }
    public void setVal(int pos,T val){
        this.arrays[pos] = val;
    }
}
//擦除后
class MyArray<T>{
    public Object[] arrays = new Object[10];
    public Object getPos(int pos){
        return this.arrays[pos];
    }
    public void setVal(int pos,T val){
        this.arrays[pos] = val;
    }
}

五、泛型的上界

5.1. 泛型的上界的定义

描述的是使用泛型，创建泛型实例的时候，传入的参数（类型实参）需要满足什么条件。

5.2. 语法规则

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

这个类型边界相当于是“父类”，后续创建类型实例的类型参数，必须是这个父类的子类。比如我们要写一个算术运算的泛型类，泛型参数必须给数字。

class MyArray<E extends Number>{
     MyArray<Integer> l1;//正常
     MyArray<String> l2;//错误
}

如果没有指定类型边界E，可以视为E extends Object。

六、泛型方法

6.1. 定义语法

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

6.2. 交换方法的实例

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

七、通配符

前面的知识都是在定义泛型时涉及到的，通配符是针对泛型实例化的时候涉及到的。

class MyClass<T>{

}
public class Main {
    public static void main(String[] args) {
        MyClass<Integer> obj1 = new MyClass<>();
        MyClass<String> obj2 = new MyClass<>();
        MyClass<Integer> obj3 = new MyClass<>();

        obj1 = obj3;//正常
        obj1 = obj2;//错误
    }
}

因为Obj1与Obj2类型不相同，所以会报错。那我们能否创建一种引用，能够指向多种泛型参数的对象呢？这时就要用到通配符了。

MyClass<?> obj4 = obj3;

MyClass<? extends Number> obj5 = obj1;
obj5 = obj2;
//这个代码不符合要求，约定obj5的通配符，只能匹配到Number和它的子类;
//因为通配符只能在泛型实例化时使用

这里的代码不要和泛型的上界搞混。我们除了可以指定父类，还能指定子类。

MyClass<? super Integer> obj6 = obj1;//此处的通配符只能匹配到Integer和它的父类
obj6 = new MyClass<double>();//double并不是Integer的子类，所以会报错
obj6 = new MyClass<Number>();//Number是Integer的父类。