【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);  //直接通过类名调用方法
    }
}
相关推荐
Yz98764 分钟前
Hadoop里面MapReduce的序列化与Java序列化比较
java·大数据·jvm·hadoop·分布式·mapreduce·big data
凯哥Java6 分钟前
优化批处理流程：自定义BatchProcessorUtils的设计与应用
java·数据库·mysql
njnu@liyong14 分钟前
AOP-前置原理-怎么判断和拦截？
java·aop·拦截
白帽黑客cst14 分钟前
网络安全（黑客技术) 最新三个月学习计划
网络·数据结构·windows·学习·安全·web安全·网络安全
末央＆19 分钟前
【C++】内存管理
java·开发语言·c++
疑惑的杰瑞31 分钟前
[数据结构]算法复杂度详解
c语言·数据结构·算法
心之语歌32 分钟前
设计模式 享元模式（Flyweight Pattern）
java·设计模式·享元模式
MTingle33 分钟前
【Java EE】文件IO
java·java-ee
大油头儿34 分钟前
排序算法-选择排序
数据结构·算法·排序算法
coffee_baby36 分钟前
享元模式详解：解锁高效资源管理的终极武器
java·spring boot·mybatis·享元模式
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04软件工程从理论到实践客观题汇总(头歌第一章至第八章)05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07CCF-CSP认证考试 202406-3 文本分词 100分题解08yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10实战 | 基于YOLOv9和OpenCV实现车辆跟踪计数（步骤 + 源码）