【JAVA数据结构】JAVA数据结构必备知识：泛型与包装类_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];
    }
}

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

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
    }

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

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

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

由此可见，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.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];
    }
}

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

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

注意：实验的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);
    }

显式装包、拆包

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();//拆包
    }

隐式装包、拆包

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

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取

g-q0UoVUbz-1714435442818)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

需要这份系统化资料的朋友，可以戳这里获取