【数据结构与算法】包装类初识泛型

一.包装类

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

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

除了 Integer 和 Character， 其余基本类型的包装类都是首字母大写。

1.2装箱和拆箱

装箱:把基本数据类型 变为 包装类类型的过程叫做装箱
拆箱:把包装类类型 变为 基本数据类型的过程叫做拆箱

public class Tset {
    public static void main(String[] args) {
        int a=10;
        Integer i=Integer.valueOf(a);//显示装箱
        Integer i2=10;//隐式装箱  底层帮我们调用了 valueof()
        System.out.println(i);
        System.out.println(i2);
    }
}

1.3自动拆箱和自动装箱

		Integer a = 10;
        int b = a; //自动的

        int c = a.intValue(); //手动的

        double d = a.doubleValue();

【面试题】

public class Test {
    //阿里巴巴
    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        System.out.println(a == b);

        Integer c = 200;
        Integer d = 200;
        System.out.println(c == d);
    }

二.什么是泛型

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

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

三.引出泛型

1.我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = newString[10];
2.所有类的父类，默认为Object类。数组是否可以创建为Object?

当我们创建了这个数组之后，这个数组里面可以存储任何类型的数据，可以是字符串，可以是整型，可以是浮点数…所以在我们想打印输出的时候，就出现了错误，获取下标元素返回的类型是Object类型的，发生了向下转型，所以此时就必须强转类型

但参数很多时怎么办呢,还要一个一个观察类型吗

此时我们希望:
1.能不能自己指定类型
2.能不能不进行强转

这里就引出了泛型:

泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

3.1 语法

class 泛型类名称<类型形参列表> {
        // 这里可以使用类型参数
    }
class ClassName<T1, T2, ..., Tn> {
}

class 泛型类名称<类型形参列表> {
        // 这里可以使用类型参数
    }
class ClassName<T1, T2, ..., Tn> {
}

示例:

class MyArray<T>{
    //public Object[] array = new Object[10];
    public T[] array = (T[])new Object[10];
    //获取pos下标的值
    public T getPos(int pos){
        return array[pos];
    }
    //给pos下标放一个元素
    public void setPos(int pos,T val){
        array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        /**
         * 1.<Integer> 指定当前类当中，使用的类型是Integer类型
         * 2.泛型帮我在编译期间做了2件事情
         * ①存放元素的时候，进行了类型的检查
         * ②取元素的时候，帮我进行了类型的转换
         * 3.<>里面必须是引用类型
         */
        MyArray<Integer> myArray = new MyArray<>();

        myArray.setPos(0,1);
        myArray.setPos(1,2);
        //myArray.setPos(1,"hello");

        Integer ret = myArray.getPos(1);
        //String ret = (String) myArray.getPos(1);
        System.out.println(ret);

        MyArray<String> myArray1 = new MyArray<>();

        myArray1.setPos(0,"abc");
        myArray1.setPos(1,"haha");
        String ret2 = myArray1.getPos(1);
        System.out.println(ret2);

    }
}

解析:

1. 类名后的代表占位符，表示当前类是一个泛型类
   了解： 【规范】类型形参一般使用一个大写字母表示，常用的名称有：
   E 表示 Element
   K 表示 Key
   V 表示 Value
   N 表示 Number
   T 表示 Type
   S, U, V 等等 - 第二、第三、第四个类型
2. 上述代码中不能new泛型类型的数组
   public T[ ] array = (T[ ])new Object[10];不可以替换成T[ ] array = new T[5];
3. <>中必须是引用类型
4. 编译器会在存放元素的时候帮助我们进行类型检查。
5. 无需强制类型转换

总结:泛型帮我们在编译期间做了2件事
①存放元素的时候，进行了类型的检查
②取元素的时候，帮我进行了类型的转换

四. 泛型的使用

4.1 语法格式

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

4.2 示例

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

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

4.3 类型推导(Type Inference)

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

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

五. 裸类型(Raw Type) （了解即可）

5.1 说明

裸类型是一个泛型类但没有带着类型实参，例如 MyArrayList 就是一个裸类型

MyArray list = new MyArray();

注意： 我们不要自己去使用裸类型，裸类型是为了兼容老版本的 API 保留的机制

小结:

1. 泛型是将数据类型参数化，进行传递
2. 使用< T > 表示当前类是一个泛型类。
3. 泛型目前为止的优点：数据类型参数化，编译时自动进行类型检查和转换

六. 泛型如何编译的

6.1 擦除机制

**泛型到底是怎么编译的？**这个问题，也是曾经的一个面试问题。

在编译的过程当中，将所有的T替换为Object这种机制，我们称为：擦除机制。

Java的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

七. 泛型的上界

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

7.1 语法

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

7.2 示例

public class MyArray<E extends Number> {
    
 }

只接受 Number或 Number 的子类型作为 E 的类型实参

了解： 没有指定类型边界 E，可以视为 E extends Object

7.3 复杂示例

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

E必须是实现了Comparable接口的

八. 泛型方法

8.1 定义语法

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

8.2 示例

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