【Java数据结构 -- 包装类和泛型】

水冠72023-11-28 6:09

包装类和泛型

  • [1. 包装类](#1. 包装类)
    • [1.1 基本数据类型和对应的包装类](#1.1 基本数据类型和对应的包装类)
    • [1.2 装箱和拆箱](#1.2 装箱和拆箱)
    • [1.3 自动装箱和自动拆箱](#1.3 自动装箱和自动拆箱)
    • [1.4 自动装箱实际上是调用了valueOf（）](#1.4 自动装箱实际上是调用了valueOf（）)
    • [1.5 Integer包装类赋值注意点](#1.5 Integer包装类赋值注意点)
  • [2 什么是泛型](#2 什么是泛型)
  • [3 引出泛型](#3 引出泛型)
  • [4 泛型的使用](#4 泛型的使用)
    • [4.1 语法](#4.1 语法)
    • [4.2 类型推导](#4.2 类型推导)
  • [5 裸类型](#5 裸类型)
  • [6 泛型如何编译](#6 泛型如何编译)
    • [6.1 擦除机制](#6.1 擦除机制)
  • [7 泛型的上界](#7 泛型的上界)
  • [8 泛型方法](#8 泛型方法)

1. 包装类

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

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

基本数据类型 --> 包装类

byte --> Byte

short --> Short

int --> Integer

long --> Long

float --> Float

double --> Double

char --> Character

boolean --> Boolean

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

1.2 装箱和拆箱

装箱/装包：把一个基本类型转变为包装类型
拆箱/拆包：把一个包装类型转变为基本类型

1.3 自动装箱和自动拆箱

java 复制代码 
    public static void main(String[] args) {
        int a = 10;
        Integer ii = a; //自动装箱

        Integer ii2 = new Integer(10);
        int b = ii2; //自动拆箱

        System.out.println(ii);  // 10
        System.out.println(b);   // 10
    }

1.4 自动装箱实际上是调用了valueOf（）

java 复制代码 
    public static void main2(String[] args) {
        int a = 10;
        //Integer ii = a; //自动装箱
        Integer ii = Integer.valueOf(a);  // 手动装箱

        Integer ii2 = new Integer(10);
        //int b = ii2; //自动拆箱
        int b = ii2.intValue(); // 手动拆箱
        double d = ii2.intValue();

        System.out.println(ii);  // 10
        System.out.println(b);   // 10
        System.out.println(d);   // 10.0
    }

1.5 Integer包装类赋值注意点

java 复制代码 
    public static void main(String[] args) {
        //  i >= IntegerCache.low && i <= IntegerCache.high
        // 在 Integer  valueOf方法中  的int i取值范围是  -128~127
        // 在这个返回返回的是  -128 到 127 中 255 个地址 存放100
        // IntegerCache.cache[i + (-IntegerCache.low)] 即返回的地址为同一个地址
        // 而200不属于这个取值范围里面 返回的是 一个新的 值 new Integer(i)
        /*Integer ii = 100;
        Integer ii2 = 100;  //true */
        Integer ii = 200;
        Integer ii2 = 200;  //false
        System.out.println(ii == ii2);
    }

2 什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。
泛型是在JDK1.5引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

3 引出泛型

实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？

java 复制代码 
class MyArray <T>{
    // <T> 占位符 是一个泛型类
    //  泛型的意义：1. 在编译的时候 检查数据类型是否正确 2.在编译的时候   帮助进行类型转化
    //public Object[] array = new Object[10];

    // 不能实例化一个泛型类型的数组
    // public T[] array = new T[10];
    
    //public T[] array = (T[])new Object[10];
    public Object[] array = new Object[10];


    public void setValue(int pos,T val) {
        array[pos] = val;
    }

    // 在java中不能将整个数组进行强转
    public T getValue(int pos) {
        return (T) array[pos];
    }

}
class Person {

}
public class Test {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();
        //MyArray<int> myArray = new MyArray<>(); //<>里面不能是基本数据类型
        myArray.setValue(1,90); // 直接放int 会发生自动装箱

        //裸类型  不加包装类型
        MyArray myArray1 = new MyArray<>();
        myArray1.setValue(0,1);
    }

    //目的：想存放指定的元素
    public static void main4(String[] args) {
        MyArray<String> myArray = new MyArray<>();
        myArray.setValue(0,"hello");



        MyArray<Integer> myArray2 = new MyArray<Integer>();//类型后加入<Integer> 指定当前类型
        myArray2.setValue(0,99);
        myArray2.setValue(1,20);

        MyArray<Person> myArray3 = new MyArray<>();
    }
}
  1. 类名后的 代表占位符，表示当前类是一个泛型类
    了解： 【规范】类型形参一般使用一个大写字母表示，常用的名称有：
  • E 表示 Element
  • K 表示 Key
  • V 表示 Value
  • N 表示 Number
  • T 表示 Type
  • S, U, V 等等 - 第二、第三、第四个类型
  1. 不能new泛型类型的数组
  2. 类型后加入 指定当前类型
  3. 不需要进行强制类型转换

4 泛型的使用

4.1 语法

java 复制代码 
//泛型类<类型实参> 变量名; // 定义一个泛型类引用
//new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象
MyArray<Integer> myArray = new MyArray<>();

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

4.2 类型推导

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

5 裸类型

java 复制代码 
        //裸类型  不加包装类型
        MyArray myArray1 = new MyArray<>();
        myArray1.setValue(0,1);

总结：

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

6 泛型如何编译

6.1 擦除机制

在终端通过命令：javap -c 查看字节码文件，所有的T都是Object。

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

即可以直接写成：

java 复制代码 
class MyArray <T>{
    //public T[] array = (T[])new Object[10];
    public Object[] array = new Object[10];


    public void setValue(int pos,T val) {
        array[pos] = val;
    }


    public T getValue(int pos) {
        return (T) array[pos]; //加(T) 转一下
    }

    public T[] getArray() {
        return (T[]) array;
    }

}

7 泛型的上界

java 复制代码 
class MyArray <T extends Number>{  // T 一定是Number或者是Number的子类如Integer
    public Object[] array = new Object[10];
    
    public void setValue(int pos,T val) {
        array[pos] = val;
    }
    public T getValue(int pos) {
        return (T) array[pos];
    }
}
    public static void main(String[] args) {
        MyArray<String> myArray = new MyArray<>();  // 报错 String不是Number的子类
        // String[] ret = (String[])myArray.getArray();  //会报错 在java中不能将整个数组进行强转
        // 数组是一种单独的数据类型
        Object[] ret = myArray.getArray();
    }

写一个泛型类， 求一个数组当中的最大值

java 复制代码 
//写一个泛型类， 求一个数组当中的最大值
class Alg<T extends Comparable<T>> {  // 泛型的上界
    public T findMaxVal(T[] array) {
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            //if (array[i] > max) {  // 引用类型不能直接通过 大于等于号进行比较
            //这个时候就需要 写一个Comparable<T> 上界
            if (array[i].compareTo(max)>0){
                max = array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,2,8,5,3};
        Alg<Integer> alg = new Alg<>();
        System.out.println(alg.findMaxVal(array)); 
    }
}

另一个类作为参数实例化时要引用它对应的接口和重写对应的方法

java 复制代码 
class Person implements Comparable<Person> {

    @Override
    public int compareTo(Person o) {
        return 0;
    }
}
   
//写一个泛型类， 求一个数组当中的最大值
class Alg<T extends Comparable<T>> {  // 泛型的上界
    public T findMaxVal(T[] array) {
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            //if (array[i] > max) {  // 引用类型不能直接通过 大于等于号进行比较
            //这个时候就需要 写一个Comparable<T> 上界
            if (array[i].compareTo(max)>0){
                max = array[i];
            }
        }
        return max;
    }
}
public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,2,8,5,3};
        Alg<Integer> alg = new Alg<>();
        System.out.println(alg.findMaxVal(array));

        //如果定义一个类 作为Alg实例的话 这个类必须实现Comparable接口并且重写compareTo方法
        Alg<Person> alg1 = new Alg<Person>();
    }
}

8 泛型方法

在定义方法的时候加

java 复制代码 
class Alg2 {
    public<T extends Comparable> T findMaxVal(T[] array) {
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i].compareTo(max)>0){
                max = array[i];
            }
        }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Alg2 alg2 = new Alg2();
        Integer[] array = {1,2,8,5,3};
        alg2.<Integer>findMaxVal(array);  //可以不加<Integer>会通过实参的值自动推导
        alg2.findMaxVal(array);
    }
}

设为静态方法static

java 复制代码 
class Alg3 {
    public static <T extends Comparable> T findMaxVal(T[] array) {
        T max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i].compareTo(max)>0){
                max = array[i];
            }
        }
        return max;
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] array = {1,2,8,5,3};
        Alg3.<Integer>findMaxVal(array);  //直接通过类名调用方法
    }
}
相关推荐
九圣残炎7 分钟前
【从零开始的LeetCode-算法】1456. 定长子串中元音的最大数目
java·算法·leetcode
wclass-zhengge9 分钟前
Netty篇（入门编程）
java·linux·服务器
lulu_gh_yu12 分钟前
数据结构之排序补充
c语言·开发语言·数据结构·c++·学习·算法·排序算法
Re.不晚36 分钟前
Java入门15——抽象类
java·开发语言·学习·算法·intellij-idea
雷神乐乐42 分钟前
Maven学习——创建Maven的Java和Web工程，并运行在Tomcat上
java·maven
码农派大星。1 小时前
Spring Boot 配置文件
java·spring boot·后端
顾北川_野1 小时前
Android 手机设备的OEM-unlock解锁 和 adb push文件
android·java
江深竹静，一苇以航1 小时前
springboot3项目整合Mybatis-plus启动项目报错：Invalid bean definition with name ‘xxxMapper‘
java·spring boot
confiself1 小时前
大模型系列——LLAMA-O1 复刻代码解读
java·开发语言
Wlq04151 小时前
J2EE平台
java·java-ee
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解