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

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

【JAVA数据结构】JAVA数据结构必备知识:泛型与包装类_第1张图片

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

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


文章目录

  • 预备知识一:泛型
    • 1.1 泛型的引入
    • 1.2 泛型语法
    • 1.3 泛型的使用
    • 1.4 泛型的背后作用时期与作用原理
  • 预备知识二:包装类
    • 2.1 基本数据类型和包装类直接的对应关系
    • 2.2 隐式转换与显式转换
    • 2.3 Integer范围分析
  • 想对大家说的话


预备知识一:泛型

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

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

我们在想:能不能存放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];
    }
}

好,我们找个例子来运行一下:

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

注意:实验的BookPerson需要事先写好哦

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

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

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

泛型的意义

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

预备知识二:包装类

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

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

【JAVA数据结构】JAVA数据结构必备知识:泛型与包装类_第2张图片
基本就是类型的首字母大写,除了 IntegerCharacter

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

● 装包,装箱:简单类型 ——> 包装类类型
● 拆箱,拆包:包装类 ——> 简单数据类型数据

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

    }

why?我们看一下Integer.valueOf装包过程的源码:ctrl + 点击
【JAVA数据结构】JAVA数据结构必备知识:泛型与包装类_第3张图片

发现问题,它有个范围:再点击

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

想对大家说的话

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

【JAVA数据结构】JAVA数据结构必备知识:泛型与包装类_第4张图片

你可能感兴趣的:(java专项突破,java,数据结构,开发语言)