【数据结构-JAVA】包装类 & 泛型

是Christy的博客呀

已于 2023-02-08 11:20:24 修改

阅读量327

点赞数 2

分类专栏： Java 文章标签： java 开发语言

于 2022-12-14 14:42:36 首次发布

本文链接：https://blog.csdn.net/qq_41233305/article/details/128299336

版权

Java 专栏收录该内容

31 篇文章 0 订阅

订阅专栏

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 装箱和拆箱

装箱，也叫装包，把基本数据类型变为对应的包装类。

    public static void main(String[] args) {
        int a = 10;
        //Integer val = a; //自动装箱
        //Integer val = (Integer)a;//自动装箱 
        Integer val = Integer.valueOf(a); //显示装箱
        //Integer val = new Integer(a); //显示装箱
        System.out.println(val);
    }

拆箱，也叫拆包，把包装类转变成基本数据类型。

    public static void main(String[] args) {
        Integer val = 100;
        int i = val; //自动拆箱
        //int i = (int)val; //自动拆箱
        System.out.println(i);
        int j = val.intValue(); //显示拆箱，拆成 int 类型
        System.out.println(j);
        double k = val.doubleValue(); //显示拆箱，拆成 double 类型
        System.out.println(k);
        float l = val.floatValue(); //显示拆箱，拆成 float 类型
        System.out.println(l);
    }

1.3 一道面试题

下面代码输出什么？

    public static void main(String[] args) {
        Integer a = 100;
        Integer b = 100;
        System.out.println(a == b);
        Integer c = 200;
        Integer d = 200;
        System.out.println(c == d);
    }

输出

true
false

IntegerCache 是 Integer 中的内部类，low 的值为 -128，而 high 的值为 127，cache 是一个数组：

在 valueOf 这个方法中，如果i ∈[-128，127]，则返回 cache 数组里的元素：

但如果 i 超出范围，那么就会返回 new 一个对象。根据前面所学我们知道，== 比较的是地址，所以比较的结果才会使 false。

2. 泛型

2.1 什么是泛型

一般的类和方法，只能使用具体的类型: 要么是基本类型，要么是自定义的类。如果要编写可以应用于多种类型的代码，这种刻板的限制对代码的束缚就会很大。

泛型是在 JDK1.5 引入的新的语法，通俗讲，泛型：就是适用于许多许多类型。从代码上讲，就是对类型实现了参数化。

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

思路：

1. 我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = new String[10];

2. 所有类的父类，默认为 Object 类。数组是否可以创建为 Object ?

class MyArray{
    public Object[] obj = new Object[3];
    public Object getPos(int pos){
        return obj[pos];
    }
    public void setObj(int pos,Object val){
        obj[pos] = val;
    }
}


public class Text {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setObj(0,100);
        myArray.setObj(1,"hello");
        myArray.setObj(2,10.5);
        int a = (int)myArray.getPos(0); //拆箱
        String b = (String)myArray.getPos(1); //拆箱
        double c = (double)myArray.getPos(2); //拆箱
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

上述数组的确可以存储任何类型的数据，但读取时，却需要强转。更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器持有特定类型的对象。此时，需要把类型，作为参数传递。需要什么类型，就传入什么类型：

class MyArray<T>{ 
    public T[] obj = (T[])new Object[3]; //*
    public T getPos(int pos){
        return obj[pos];
    }
    public void setObj(int pos,T val){
        obj[pos] = val;
    }
}
public class Text {
    public static void main(String[] args) {
        //实例化对象的同时，指定当前泛型类的指定参数类型是 Integer
        MyArray<Integer> myArray = new MyArray<Integer>(); //**
        //就可以存储指定的数据类型
        myArray.setObj(0,100); //#
        myArray.setObj(1,121);
        myArray.setObj(2,141);
        int a = myArray.getPos(0); //***
        System.out.println(a);
        System.out.println("==========================");
        //实例化对象的同时，指定当前泛型类的指定参数类型是 String ，第二个< >的内容可以省略
        MyArray<String> myArray1 = new MyArray<>();
        myArray1.setObj(0,"haha");
        myArray1.setObj(1,"heihei");
        myArray1.setObj(2,"hehe");
        String b = myArray1.getPos(1);
        System.out.println(b);
    }

代码解释：

1. 类名后的<T>代表占位符，表示当前类是一个泛型类

了解：

【规范】类型形参一般使用一个大写字母表示，常用的名称有：

E 表示 Element

K 表示 Key

V 表示 Value

N 表示 Number

T 表示 Type

S, U, V 等等 - 第二、第三、第四个类型

2. 注释 * 处，不能 new 泛型类型的数组，即泛型类当中，不能实例化一个泛型类数组：

T[] ts = new T[3];//是不对的

3. 泛型是把类型作为参数传递，泛型只能接受类，所有的基本数据类型必须使用包装类！注释 ** 处，< >里指定的参数类型必须是引用类型，而不能是基本数据类型

4. 注释 *** 处，不需要进行强制类型转换，编译器会自动帮我们数据转换

5. 注释 # 处，编译器会在存放元素的时候帮助我们进行类型检查

第四、第五点是泛型在编译时完成的。

3. 泛型是如何编译的

3.1 擦除机制

那么，泛型到底是怎么编译的？

IDEA 点击 View -> Show ByteCode :

可以看到，在编译完成之后，编译器将所有的 T 替换为 Object ，这种机制，我们称为：擦除机制。 Java 的泛型机制是在编译级别实现的。编译器生成的字节码在运行期间并不包含泛型的类型信息。

官方中，对于泛型类的数组声明是不写成这样的：public T[] obj = (T[])new Object[3];

官方的正确写法：

class MyArray<T>{
    //public T[] obj = (T[])new Object[3];
    public Object[] obj = new Object[3]; //在 Java 官方中，泛型类中的数组声明
    public T getPos(int pos){
        return (T)obj[pos];
    }
    public void setObj(int pos,T val){
        obj[pos] = val;
    }
}

4. 泛型的上界

由于泛型的擦除机制会将传入的类型变量擦除成 Object 类，但有时需要对传入的类型变量做一定的约束，可以通过类型边界来约束。

class 泛型类名称 <类型形参 extends 类型边界> {

......

}

类型边界有两种，一是接口，意味着指定的参数类型一定实现了该接口，二是某一具体类，意味着形参是该类的子类，或是该类本身。

示例1：

类型边界为接口：找到数组中的最大值

class Alg<E extends Comparable>{
    public E findMax(E[] arrays){
        E max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(max.compareTo(arrays[i]) < 0){
                max = arrays[i];
            }
        }
        return max;
    }
}

public class Text {
    public static void main(String[] args) {
        Alg<Integer> alg = new Alg<>();
        Integer[] arr = {1,2,5,7,24,62,555,36,77,42,31,59,92};
        Integer max = alg.findMax(arr);
        System.out.println(max);
    }
}

示例2：

类型边界为 Number 类：

通过查询帮助手册可知，Number 有以下我们所熟悉的包装类：

但如果没写，默认是 Object 类。

5. 泛型方法

基本语法：

方法限定符 <类型形参列表 extends 边界类型>返回值类型方法名称(形参列表) {

......

}

class Alg1 {
    public<E extends Comparable<E>> E findMax1(E[] arrays){
        E max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(max.compareTo(arrays[i]) < 0){
                max = arrays[i];
            }
        }
        return max;
    }
}
public class Text {
    public static void main(String[] args) {
        Alg1 alg1 = new Alg1();
        Integer[] arr = {1,2,5,7,24,62,555,36,77,42,31,59,92};
        Integer max = alg1.<Integer>findMax1(arr);
        //也可以省略：Integer max = alg1.findMax1(arr);
        System.out.println(max);
    }
}

也可以使用泛型的静态方法：

class Alg2 {
    public static <E extends Comparable<E>> E findMax1(E[] arrays){
        E max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(max.compareTo(arrays[i]) < 0){
                max = arrays[i];
            }
        }
        return max;
    }
}
public class Text {
    public static void main(String[] args) {
        Integer[] arr = {1,2,5,7,24,62,555,36,77,42,31,59,92};
        Integer max = Alg2.findMax1(arr);
        System.out.println(max);
    }
}

泛型没有下界，但通配符有下界