数据结构（JAVA）包装类泛型

包装类

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

注意，除了int基本数据类型的包装类是Integer和char基本数据类型的包装类是Character以外的基本数据类型的包装类都是首字母大写。

装箱和拆箱

装箱：把基本数据类型变成包装类的过程，就叫作装箱。
拆箱：把包装类变成基本数据类型的过程，就叫作拆箱。
装箱分为显示装箱和自动装箱。
拆箱分为显示拆箱和自动拆箱。

显示装箱和自动装箱

    public static void main(String[] args) {
        int a = 15;
        Integer a1 = Integer.valueOf(a);//显示装箱
        Integer a2 = a;//自动装箱
    }

显示拆箱和自动拆箱

    public static void main(String[] args) {
        Integer a = 15;
        int a1 = a.intValue();//显示拆箱
        int a2 = 15;//自动拆箱
    }

自动装箱，自动拆箱的原理
自动装箱和自动拆箱的原理都是底层帮助我们调用valueOf 或者 intValue方法；

面试题

下面的代码的运行结果是什么？

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);
}

当我们把上述代码运行，发现结果令人惊讶

为什么呢？明明两个结果都应该是true，但第一个是true 第二个是false?
我们发现这两个都是装箱操作，那么我们装箱是怎么工作的，也就是valueOf的逻辑是什么。
观察valueOf方法，当我们给valueOf方法传入一个值，并且他满足一定范围，返回一个数组值，不满足返回新的对象。

那这个方法的值范围是多少呢？

范围是[-128,127]。

泛型

什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的
代码，这种刻板的限制对代码的束缚就会很大。---- 《Java编程思想》
通俗来讲，就是适用于许多许多类型。把想要的数据类型当作参数传递，需要什么类型，就传入什么类型。

泛型的语法

class 泛型类名称<类型形参列表> {
    // .....
}

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

泛型类的使用

泛型类的语法

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

new后面的<类型实参>中的类型实参可以省略，编译器可以根据上下文推导出类型实参。

泛型的使用

class MyArray <E>{
    public Object[] objects = new Object[10];

    public void setVal(int pos,E val) {
        objects[pos] = val;
    }

    public E getVal(int pos) {
        return (E)objects[pos];
    }
}

public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();
        myArray.setVal(0,12);
        myArray.setVal(1,13);
        Integer a = myArray.getVal(1);
        System.out.println(a);
    }
}

我们以Integer为例，当我们以Integer类型当作参数传入，那E类型必须是整数类型，不能是其他类型。
如果传入其他类型，编译器会通过自动类型检查发现错误并报错。

注意<>内只能写类类型，不能写简单类型。

裸类型(Raw Type) （仅需了解）

裸类型是一个泛型类但没有带着类型实参（为了兼容老版本的api）

擦除机制

擦除机制：就是在编译时，将所有的E替换Object。

泛型的上界

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

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

class MyArray <E extends Number>{
    public Object[] objects = new Object[10];

    public void setVal(int pos,E val) {
        objects[pos] = val;
    }

    public E getVal(int pos) {
        return (E)objects[pos];
    }
}

当我们规定E的上界时，此时传入的参数必须是Number或者是Number的子类。
如果不是将会报错。

示例二

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

写一个泛型方法，求数组中的最大值。

观察上面的代码，发现在if判断句报错，这是为什么呢？
因为E的类型我们不知道，我们无法比较。
解决方法：让E继承Comparable接口。

class Alg <E extends Comparable<E>> {
    public E findMax(E[] array) {
        E max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

注意<>中的数据类型必须实现了Comparable接口。如果没有将会报错

泛型方法

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

class Alg1 {
    public <E extends Comparable<E>>  E findMax(E[] array) {
        E max = array[0];
        for (int i = 1; i < array.length; i++) {
            if(max.compareTo(array[i]) < 0) {
                max = array[i];
            }
        }
        return max;
    }
}

调用泛型方法，有俩种。
1.java通过参数传递，推导出类型。
2.手动添加类型。