【JAVA数据结构】JAVA数据结构必备知识：泛型与包装类

希望我们一直在一起，今年，明年，年年

大家好，这里是新一，请多关照🙈🙉🙊。在本篇博客中，新一将会为大家介绍JAVA数据结构 - 泛型与包装类，干货满满哟。（以下结果均在IDEA中编译）希望在方便自己复习的同时也能帮助到大家。😜😜😜🥇🥈🥉

废话不多说，直接进入我们的文章。

---

---

🌕 预备知识一：泛型

此处我们只对泛型做一个了解，在后续更新中我们会对泛型进行深入学习

1.1🍂 泛型的引入

我们之前博客中实现的顺序表，是不是如下：

class MyArrayList1 {
    private int[] elem;
    private int usedSize;

    public MyArrayList1() {
        this.elem = new int[10];
    }

    public void add(int val){
        this.elem[usedSize] = val;
        usedSize++;
    }
    public int get(int pos){
        return this.elem[pos];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

我们在想：能不能存放String类型呢，显然是不能的，我们这样的顺序表一旦写成就只能存放一种数据类型十分不方便

此外，我们知道

1. 首先，我们在学习多态过程中已知一个前提，基类的引用可以指向子类的对象。
2. 其次，我们也已知 Object 是 java 中所有类的祖先类

那么我们将顺序表元素定义成Object类型不就可以啦？

class MyArrayList2 {
    private Object[] elem;
    private int usedSize;

    public MyArrayList2() {
        this.elem = new Object[10];
    }

    public void add(Object val){
        this.elem[usedSize] = val;
        usedSize++;
    }
    public Object get(int pos){
        return this.elem[pos];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

好，我们找个例子来运行一下：

public static void main(String[] args) {
        MyArrayList2 myArrayList2 = new MyArrayList2();
        myArrayList2.add(1);
        myArrayList2.add("hello");
        String ret = (String) myArrayList2.get(1);
        System.out.println(ret);//hello
    }
1
2
3
4
5
6
7

这样也运行出来了啊，没问题啊？真的吗？假如我们顺序表内存一个Book类，然后我们将其转为我们自定义的Person类

MyArrayList books = new MyArrayList(); 
books.add(new Book); 

ClassCastException Person person = (Person)books.get(0);
// 将 Object 类型转换为 Person 类型，需要类型转换才能成功 
// 这里编译正确，但运行时会抛出异常 
1
2
3
4
5
6

由此可见，Object类也有如下缺点：

1. 存放元素不能指定元素
2. 每次取出数据都需要进行强制类型转换
3. 编译期间不能进行检查

由此，我们便诞生了泛型：分为泛型方法和泛型类

1.2🍂 泛型语法

这里我们只了解简单的定义即可：

// 1. 尖括号 <> 是泛型的标志 
// 2. E 是类型变量(Type Variable)，变量名一般要大写 
// 3. E 在定义时是形参，代表的意思是 MyArrayList 最终传入的类型，但现在还不知道 
public class MyArrayList<E> { 
private E[] array; 
private int size; 
... 
}
1
2
3
4
5
6
7
8

注意： 泛型类可以一次有多个类型变量，用逗号分割

1.3🍂 泛型的使用

我们用泛型来表示我们的顺序表：

class MyArrayList3 <E>{
    private E[] elem;
    private int usedSize;

    public MyArrayList3() {
        this.elem = (E[]) new Object[10];
        //this.elem = new E[10];
    }

    public void add(E val){
        this.elem[usedSize] = val;
        usedSize++;
    }
    public E get(int pos){
        return this.elem[pos];
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这样我们就可以定义各种数据类型的元素了

public static void main4(String[] args) {
        MyArrayList3<String> myArrayList3 = new MyArrayList3<>();
        System.out.println(myArrayList3);
        MyArrayList3<Integer> myArrayList31 = new MyArrayList3<>();
        System.out.println(myArrayList31);
        MyArrayList3<Boolean> myArrayList32 = new MyArrayList3<>();
        System.out.println(myArrayList32);

        // 定义了一个元素是 Book 引用的
        MyArrayList MyArrayList<Book> books = new MyArrayList<Book>();
        books.add(new Book());
        //会产生编译错误，Person 类型无法转换为 Book 类型
        books.add(new Person());
        // 不需要做类型转换
        Book book = book.get(0);
        // 不需要做类型转换
        // 会产生编译错误，
        Book 类型无法转换为 Person 类型
        Person person = book.get(0);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

注意：实验的Book跟Person需要事先写好哦

通过以上代码，我们可以看到泛型类的一个使用方式：只需要在所有类型后边跟尖括号，并且尖括号内是真正的类型，即 E 可以看作的最后的类型。但Book 只能想象成 E 的类型，但实际上 E 的类型还是 Object。

1.4🍂 泛型的背后作用时期与作用原理

● 泛型是作用在编译期间的一种机制 —— 擦除机制，即运行期间没有泛型的概念。
● 泛型代码在运行期间，就是我们上面提到的，利用 Object 达到的效果（我们以前说过的反射机制）。

泛型的意义

1. 自动对类型进行检查
2. 自动对类型进行强转
3. 泛型不参与数据类型的组成

🌕 预备知识二：包装类

Object 引用可以指向任意类型的对象，但有例外出现了，8 种基本数据类型不是对象，那岂不是刚才的泛型机制要失效了？
实际上也确实如此，为了解决这个问题，java 引入了一类特殊的类，即这 8 种基本数据类型的包装类，在使用过程中，会将类似 int 这样的值包装到一个对象中去。

2.1🍂 基本数据类型和包装类直接的对应关系

基本就是类型的首字母大写，除了 Integer 和 Character。

2.2🍂 隐式转换与显式转换

包装类数据类型转换

public static void main(String[] args) {
        Integer a = 12345;
        String str = "123";
        int ret = Integer.valueOf(str);//借助valueof实现数据类型转换
        System.out.println(ret + 1);
    }
1
2
3
4
5
6

显式装包、拆包

public static void main(String[] args) {
        //显式转换
        System.out.println("=============");
        Integer a2 = Integer.valueOf(123);//装包
        Integer a3 = new Integer(123);//装包

        int b2 = a2.intValue();//拆包
        double d = a2.doubleValue();//拆包
    }
1
2
3
4
5
6
7
8
9

隐式装包、拆包

public static void main(String[] args) {
        //隐式转换
        Integer a = 123;//装包
        int b = a;//拆包
        System.out.println(a + " " + b);
    }
1
2
3
4
5
6

● 装包，装箱：简单类型 ——> 包装类类型
● 拆箱，拆包：包装类 ——> 简单数据类型数据

2.3🍂 Integer范围分析

我们来看如下代码：

public static void main(String[] args) {
        //why？
        //看源码分析范围
        Integer a1 = 123;
        Integer b1 = 123;
        System.out.println(a1 == b1);//true

        Integer a2 = 128;
        Integer b2 = 128;
        System.out.println(a2 == b2);//false

    }
1
2
3
4
5
6
7
8
9
10
11
12

why？我们看一下Integer.valueOf装包过程的源码：ctrl + 点击

发现问题，它有个范围：再点击

至此，谜题解开，我们发现Integer装包的数据范围是-128 - 127，我们知道对于一个类，你实例化一个类对象时，对象可以通过引用调用其中的成员，此时你比较实际上是比较的地址，一旦超过上述数据范围，那么将会在JVM上开辟一段新的地址，因此第二段代码结果为false，我们也可调试验证

想对大家说的话

家人们，学到这里我们的JAVA数据结构预备知识已经过关了，🥳🥳🥳，后续新一会持续更JAVA的有关内容，学习永无止境，技术宅，拯救世界！