深入了解包装类 

我们在最开始学习Java的数据类型时，就知道了Java的八大基本数据类型有自己对应的包装类，也就是引用类型。今天，我们就来彻底了解它们。

包装类的由来

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

基本类型与其对应的包装类 类型

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

装箱与拆箱 

装箱也叫作：装包。就是把基本数据类型转换成其对应的包装类 类型。

例如：

public class Test {
    public static void main(String[] args) {
        Integer a = 10;

        Integer c = new Integer(10);

        Integer b = Integer.valueOf(10);


        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

上面三种写法，都是装箱的操作，即把基本数据类型转换成其对应的包装类 类型。但要注意的是第二种方法，虽然代码可以正常执行，但我们现在不再使用这种方法了。从Java 9开始，这个方法就已经被摒弃了。下面是Java 8 和 Java 17的不同情况：

Java 8：

Java 17： 

需要注意的是：这里爆红，但还是可以运行通过的。 

拆箱也叫作：拆包。就是把包装类 类型转换成其对应的基本数据类型。

例如：

public class Test {
    public static void main(String[] args) {
        Integer integer = 10;

        int a = integer;

        int b = integer.intValue();

        System.out.println(a);
        System.out.println(b);
    }
}

注意：

当我们显式地去调用方法来进行装箱或者拆箱操作时，这种方式叫做：显式装箱（拆箱）。

当我们直接把基本数据类型转换为其对应的包装类 类型或者进行这种拆箱操作时，这就叫做：自动装箱（拆箱）。

public class Test {
    public static void main(String[] args) {
        Integer a = 10; // 自动装箱
        Integer b = Integer.valueOf(10); // 显式装箱
        
        int c = a; // 自动拆箱
        int d = b.intValue(); // 显式拆箱
    }
}

面试题 

public class Test {
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        System.out.println(a == b); // 结果是 true

        Integer c = 200;
        Integer d = 200;
        System.out.println(c == d); // 结果是 false
    }
}

这里同样都是自动装箱，为什么输出的结果会不一样呢？

分析：a b c d 在这里都是一个引用类型，那么在用 == 比较时，比较的是它们各自在堆区的地址。这也就说明 a 和 b在堆区是同一块地址，但是c 和 d 在堆区不是同一块地址。

我们就可以去看这个装箱的源码，看看到底做了什么？ 

可以看到当装箱的 i 的值在 [low, high] 之间的时候，返回的是一个数组所对应的下标的值，而当 i 不在这个范围内时，返回的是一个新的对象。因此，我们可以得出结论了：100在这个范围内，200不在这个范围内。我们还是可以看一个这个源码对应的 low 和 high 的值的。

low 对应的值是 -128，high 对应的值是 127。 

根据条件得出这个数组大致是这样的。因此 当 i = 100时，返回的是在数组中的同一份；而 i  = 200时，返回的是 new 的一个新对象。 

泛型            

包装类的出现就是为泛型服务的。那么什么是泛型呢？顾名思义：就是一个广泛的类型。泛型的出现是为了解决掉：一个类或者方法只能解决对应类型的问题。

例如：对整型数据排序，就只能用整型数组类解决。

class Myarray {
    public static void bubble_sort (int[] array) {
        // 趟数
        for (int i = 0; i < array.length; i++) {
            boolean flag = true;
            // 每一趟要比较的内容
            for (int j = 0; j < array.length-i-1; j++) {
                if (array[j] > array[j+1]) {
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                    flag = false;
                }
            }
            if (flag) {
                break;
            }
        }
    }
}
public class Test {
    public static void main(String[] args) {
        int[] array = {10,9,8,7,6,5,4,3,2,1};
        System.out.println("排序前："+ Arrays.toString(array));
        Myarray.bubble_sort(array);
        System.out.println("排序后："+ Arrays.toString(array));
    }
}

从排序的结果来看：这个排序的功能是正确的。但是也只局限于排序整型数据，不能排序其他类型的数据，如果要排序的话，还得重新写一个这样的方法。于是就出现了泛型。 所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。

泛型的语法与使用

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

 这里的参数列表可以不只有一种。就像下面这样：

class 泛型类名称<T1,T2,....,Tn> {
    
}

这里的T代表的是占位符，表示当前类是一个泛型类。

类型形参一般使用一个大写字母表示，常用的名称有：

E 表示 Elements               K 表示 Key                                             V  表示 Value 

N 表示 Number                 T 表示 Type                S, U, V 等等 - 第二、第三、第四个类型

至于这些占位符的区别以及各自之间的含义，我们待会再学习。我们可以用一个数组来接收多种不同的元素了。

class MyArray<T> {
    // 语法规定不能创建泛型数组，但Object可以拥有接收所有类的功能
    public Object[] objects;
    public MyArray(){
        this.objects = new Object[10];
    }
    public T getValue(int pos) {
        // 取出来的是一个Object类，得强转成 T
        return (T)objects[pos];
    }
    public void setValue(int pos, T value) {
        // 这里不考虑pos的无效，注重这里的思想
        objects[pos] = value;
    }
}

public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myarray = new MyArray<>();
        myarray.setValue(0, 10);
        myarray.setValue(1, 20);


        //                                  这里可写可不写
        MyArray<String> myArray = new MyArray<String>();
        myArray.setValue(0, "Hello");
        myArray.setValue(1, "World");
    }
}

这里就实现了同一个类，但是可以接收不同的类型，实现了类型的参数化。这就是泛型的意义。

注意：

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

2. 编译器会根据我们在实例化一个对象的时候来判断这个T到底是什么类型。

3. 我们也可能会遇到有的代码在使用泛型类时，没有标明具体的类型，但是还是可以运行通过。这是因为泛型这个概念是在 java 5之后提出来的。之前的 java 版本并没有这种写法，所以为了兼容老版本，泛型类在实例化时，会有未标明具体类型的情况，这种叫做裸类型。但是我们最好不要写这种代码出来。

泛型如何编译的 

泛型是只存在于编译时期的名词，因为在编译过后不存在T、E等泛型占位符了。泛型的占位符在编译之后就被替换成了Object。这种机制被称为“擦除机制” 。将占位符擦除成Object。

泛型的上界

 如果我们想要限制泛型的传过来的种类也是可以的。

在定义泛型类时，有时需要对传入的类型变量做一定的约束（就像上面那样），可以通过类型边界来约束。 

 语法：

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

注意：其实所有的泛型类都有一个上界：Object。 

泛型方法 

语法：

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

例如：

// 规定这个方法是叫把pos位置的值置为value
public static <T> void swap (T[] array, int pos, T value) {
    array[pos] = value;
}

注意：只有静态的泛型方法里面才能有泛型的出现，普通的静态方法不能有泛型的出现。

这句话不是说只有静态方法才能是泛型方法，普通方法也可以是泛型方法。只是说不是泛型的方法里面如果没有实例化泛型对象，就不能出现任何与泛型有关的东西。

因此，上面的排序就可以用泛型方法来解决。但是会有一个新的问题：Comparable 与 这个数组会出现不兼容的情况，因为这个数组是基本数据类型，没有实现接口这一说法。所以得把这个数组变成包装类，但是在传参的过程中，T会被擦除成Object类，因此即使我们传过去的参数强转成T[ ]，也会发生类型转换异常。

因此这个排序最终是失败了。所以我就没有把代码传上来。但是泛型还是有很大的好处的：可以让一份代码对不同的对象执行相同的操作。 

类型推导 

class Myarray<T> {
    // ......
}


public class Test {
    public static void main(String[] args) {
        // 通过这个 Integer 来推导出 Myarray 中的泛型
        Myarray<Integer> myarray = new Myarray<>();
    }
}

上面是泛型类的推导。下面是泛型方法的推导 

 

class Myarray {
    public <T> void func () {
        // ......
    }
}


public class Test {
    public static void main(String[] args) {
        Myarray myarray = new Myarray();
        // 通过这个 Integer 来推断这个 T（也可以不写，编译器会根据其具体操作来判断）
        myarray.<Integer>func();
    }
}

泛型占位符

接下来就学习泛型占位符的知识：

在Java泛型中，像 <T> 和 <E> 这样的占位符是用来表示类型参数的。它们本身没有本质上的区别，都代表一种未知的类型，将在编译时期由具体的实际类型替换。选择使用T、E或其他的，更多是基于习惯和上下文的清晰性。以下是几个常用的占位符及其常见用途：

• T - 通常代表 Type，是最常见的泛型占位符，用于表示任何类型。在没有特定上下文暗示的情况下，泛型类或方法常使用 T。

• E - 通常代表 Element，特别在集合框架中使用较多，暗示它代表集合中的元素类型，如 List<E> 或 set<E>。

• K - 代表 Key，通常用在表示键的类型，比如在 Map <K，V> 中。

• V - 代表 Value，通常与 K 一起使用，表示映射中的值类型。

• N - 有时代表 Number，表示数值类型，尽管这不是Java标准库中的正式约定，但在特定上下文中可能会看到它的使用。

使用这些占位符主要是为了提高代码的可读性和自文档化能力。开发者可以根据上下文选择最合适的占位符来表达意图，但最终这些占位符都会被编译器替换为具体的类型信息，不会影响到生成的字节码或运行时行为。

此外，泛型中还有一个特殊的占位符 ?（问号），它作为通配符使用，表示未知的类型，可以有三种形式：无界通配符（?）、上界通配符（? extends SomeType）和下界通配符（? super SomeType），用来实现更灵活的泛型参数约束。（了解即可）

这里基本就是java泛型语法的全部内容啦！通过对泛型的学习，我们就可以让代码变得更加高大上一些。

好啦！本期 数据结构之初始泛型 的学习之旅就到此结束了！相信通过这篇文章的学习，你对Java中泛型的了解将会更进一步！我们下一期再一起学习吧！