Java面向对象（高级）-- 包装类（wrapper）的使用

最新推荐文章于 2024-07-23 09:37:00 发布
最新推荐文章于 2024-07-23 09:37:00 发布
阅读量804 收藏 5
点赞数 7
分类专栏： Java基础 文章标签： java 面向对象（高级） 包装类 Wrapper
不要随意搬运哦，私信博主同意之后再转载~
本文链接：https://blog.csdn.net/m0_55746113/article/details/134990781
版权

文章目录

一、概念

（1）为什么需要包装类

Java提供了两个类型系统，基本数据类型与引用数据类型。使用基本数据类型在于效率，然而当要使用只针对对象设计的API或新特性（例如泛型），怎么办呢？例如：

//情况1：方法形参
Object类的equals(Object obj)	

//情况2：方法形参
ArrayList类的add(Object obj)	
//没有如下的方法：
add(int number)
add(double d)
add(boolean b)

//情况3：泛型
Set<T>
List<T>
Cllection<T>
Map<K,V>

①情况1：方法形参

Object类的equals(Object obj)

equals用于比较引用数据变量是否相等，形参只能传Object类型，可以传各个类的对象（以多态的方式传进来），在Object的API声明当中，数组也可以看作Object实例，所以也可以放数组。

现在的问题是，基本数据类型传不过来。

②情况2：方法形参

ArrayList类的add(Object obj)

ArrayList是集合中的一个类，里面有个add方法，形参是Object类型的。

若是现在想使用这个容器，往里面放学生的成绩，学生成绩是int类型的，这是放不进去的。因为add方法在ArrayList中只提供了add(Object obj)这一个方法，没有重载（比如形参是int类型）的方法。

所以，没有如下的方法：

add(int number)
add(double d)
add(boolean b)

③情况3：泛型

后边还会讲一个新特性“泛型”，这个T，我们在使用这个类的时候需要指明它是什么类型，Java规范中说，T只能是引用数据类型。

所以基本数据类型放不进来。

Set<T>
List<T>
Cllection<T>
Map<K,V>

使用基本数据类型在于效率，但是在很多场景下，我们希望它具备类的特征。

换句话说，能不能让基本数据的值作为一个像对象一样的结构放到形参的位置，作为实参来出现。

基本数据类型需要一波类与它们有一一对应的关系，这一波类就是包装类。

（2） 有哪些包装类

Java针对八种基本数据类型定义了相应的引用类型：包装类（封装类）。

有了类的特点，就可以调用类中的方法，Java才是真正的面向对象。

下面蓝色虚线里面都是数值类型的，这些数值类型它们默认父类是Number，而Number继承于Object。

image.png

比如现在有个学生成绩Score，是int类型，为80，然后我们就需要用一个Integer类的对象来表示它的成绩，成绩也是80，实际上是Integer这个对象内部有一个属性，这个属性是int类型的，它是80分。

封装以后的，内存结构对比：

public static void main(String[] args){
	int num = 520;	//局部变量
	Integer obj = new Integer(520);
}

原来的时候，在Main方法中声明了一个局部变量num，值为520，这时候就是纯粹的在栈空间中（main方法的栈帧里面有一个num，值为520）。

若是以一个对象的方式去呈现，那就是new了一个Integer，new的都是对象，放在堆空间里面，变量obj放在栈帧中，指向堆空间创建的对象实体，对象实体里面有个属性是int类型的，对应的值是520。

原来的变量名是num，现在只是将一个也是int类型的变量，拿类给它包装了一下，使它具备类的特征。

image.png

把基本数据类型包装了一下，就是包装类。使基本数据类型具备了类的特征。

（3）总结

  1. 为什么要使用包装类？
    为了使得基本数据类型的变量具备引用数据类型变量的相关特征（比如：封装性、继承性、多态性），我们给各个基本数据类型的变量都提供了对应的包装类。

  2. (掌握)基本数据类型对应的包装类类型
    数值类型（继承于Number）：
    byte -> Byte
    short -> Short
    int ->Integer
    long -> Long
    float -> Float
    double ->Double

不继承于Number：

char -> Character

boolean -> Boolean

左边是基本数据类型，对应也叫“关键字”；右边就只是类，不是关键字。

二、包装类

（1）自定义包装类

如果自己去定义包装类的话，就是这样：

public class MyInteger {
    int value;

    public MyInteger() {
    }

    public MyInteger(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

这里定义了一个MyInteger，和Integer的定义方式基本一样。

在类里面声明一个int型的变量，这个变量习惯性叫value。

然后对应提供构造器，以及toString方法（把值打印一下，不要默认打印地址）。

当我们通过MyInteger的构造器MyInteger(int value)造对象的时候，比如MyInteger obj = new MyInteger(520);传一个520，那么形参value就将实参520传递过来，最终就把MyInteger的属性值value改为了520。

以前咱们都是直接给value赋值为520，现在是赋给MyInteger对象的一个属性value。

原来是直接Int学生成绩，现在是以一个对象的形式来出现的。

继而我们就可以将它放到刚才说的形参的位置了，就可以使用类中丰富的特征了。比如：Object类的equals(Object obj)

（2） 包装类与基本数据类型间的转换

2.1 为什么需要转换

  • 对于基本数据类型来讲，在有些场景下，需要使用基本数据类型对应的包装类的对象。此时就需要将基本数据类型的变量转换为包装类的对象。比如：ArrayList的add(Object obj); 、Object类的equals(Object obj)。
  • 对于包装类来讲，既然我们使用的是对象，那么对象是不能进行+ - * /等运算的。为了能够进行这些运算，就需要将包装类的对象转换为基本数据类型的变量。

2.2 装箱

装箱：把基本数据类型转为包装类对象

（装箱）基本数据类型 —> 包装类：① 使用包装类的构造器 ② （建议）调用包装类的valueOf(xxx xx)

转为包装类的对象，是为了使用专门为对象设计的API和特性

基本数值---->包装对象

Integer obj1 = new Integer(4);//使用构造函数函数
Float f = new Float(“4.56”);
Long l = new Long(“asdf”);  //NumberFormatException

Integer obj2 = Integer.valueOf(4);//使用包装类中的valueOf方法

【案例】

public class WrapperTest {
    //把基本数据类型包一下，让它具备类的特征，里面很多方法就可以去使用了

}

现在创建一个单元测试：

image.png

前面说注解的时候，已经将“单元测试”设置为模板了，不会的去前面的文章看一看。
Java面向对象（高级）-- 注解(Annotation)-CSDN博客

2.2.1 方式一、使用包装类的构造器

【案例1】

现在定义一个int类型的变量i1，如下：

public class WrapperTest {
    //把基本数据类型包一下，让它具备类的特征，里面很多方法就可以去使用了
    /*
    * （装箱）基本数据类型 ---> 包装类：① 使用包装类的构造器 ② （建议）调用包装类的valueOf(xxx xx)
    * */
    @Test
    public void test1(){
        int i1 = 10;  //创建一个int型的变量
    }
}

此时它没有什么方法可用：

image.png

现在将它包装起来。

这样：

image.png

可以看到，Integer()两个参数都过时了。

这里先用一下。（JDK9被标记为过时，不建议使用了）

image.png

现在建议使用的是valueOf(int)，如下：（这个等会再说）

image.png

这是第一种方式，比较传统，就是把刚才的基本数据类型的值传给当前类里面的成员变量。

image.png

现在的ii1已经是一个对象了，所以用它点的时候，就有很多方法可以去调用了。

而且还可以以多态的方式出现在方法形参的位置。

如下：

image.png

🌱代码

public class WrapperTest {
    //把基本数据类型包一下，让它具备类的特征，里面很多方法就可以去使用了
    /*
    * （装箱）基本数据类型 ---> 包装类：① 使用包装类的构造器 ② （建议）调用包装类的valueOf(xxx xx)
    * */
    @Test
    public void test1(){
        int i1 = 10;  //创建一个int型的变量  基本数据类型
        Integer ii1=new Integer(i1);    //包装起来了，具备了类的特征  对象
        System.out.println(ii1);    //结果是数据
    }
}

🍺输出结果

image.png

【案例2】

再举两个例子：

🌱代码

public class WrapperTest {
    //把基本数据类型包一下，让它具备类的特征，里面很多方法就可以去使用了
    /*
    * （装箱）基本数据类型 ---> 包装类：① 使用包装类的构造器 ② （建议）调用包装类的valueOf(xxx xx)
    * */
    @Test
    public void test1(){
        int i1 = 10;  //创建一个int型的变量  基本数据类型
        Integer ii1=new Integer(i1);    //包装起来了，具备了类的特征  对象
        System.out.println(ii1);    //结果是数据，不是地址

        float f1=12.3F;
        f1=32.2f;
        Float ff1=new Float(f1);
        System.out.println(ff1.toString());

        boolean b1=true;
        Boolean bb1=new Boolean(b1);
        System.out.println(bb1);
    }
}

🍺输出结果

image.png

其实Float()里面可以传的参数有好几个，包括float类型、double类型、String类型。

如下：

image.png

比如现在传一个字符串：

package yuyi03;

import org.junit.Test;

public class WrapperTest {
    @Test
    public void test1(){
        String s1="32.4";   //“ ” 的里面还是一个float或者double类型的即可
        Float ss1=new Float(s1);
        System.out.println(s1);

    }
}

输出结果：

image.png

只要双引号““ 的里面还是一个float或者double类型的即可，若传入的不是浮点型的数据，就会报错，如下：

image.png

所以，双引号里面放的不是数，就会有数据格式化异常NumberFormatException。

要是传递一个基本数据类型是可以的，也可以放字符串，但是字符串内容必须是实打实的相对应的类型的数，不是的就不行。

【案例3】

那布尔类型呢？

比如：

package yuyi03;

import org.junit.Test;

public class WrapperTest {

    @Test
    public void test1(){

        boolean b1=true;
        Boolean bb1=new Boolean(b1);
        System.out.println(bb1);

        String s2="false";
        Boolean bb2=new Boolean(s2);
        System.out.println(s2);

    }
}

输出结果：

image.png

若此时将false大写呢？比如：s2="False";

image.png

可以发现它没有报错，说明“False”也可以使用。

那如果是“False123”呢？

image.png

所以布尔类型有点特殊，只要和“true”不一样，那就都是false。

可以看一下它调用的是哪一个函数：

PixPin_2023-12-10_17-11-24.gif

"true".equalsIgnoreCase(s)：在忽略大小写的情况下，如果和true一样，那就返回true。如果不一样，那就认为是false。

比如：

image.png

2.2.2 方式二、（建议）调用包装类的valueOf(xxx xx)

以Integer为例：

image.png

可以看到，这里建议用valueOf(Xxx)来替换Integer。

因为它可能产生明显更好的空间和时间性能。

image.png

【案例1】

image.png

🌱代码

package yuyi03;

public class WrapperTest {
    @Test
    public void test1(){

    	//推荐使用
        
       //Integer类型
        int i2=10;
        Integer ii2= Integer.valueOf(i2);
        System.out.println(ii2);

        //Boolean类型
        Boolean b2=Boolean.valueOf(true);
        System.out.println(b2);

        //Float类型
        Float f2=Float.valueOf(12.3F);
        System.out.println(f2);
    }
}

🍺输出结果

image.png

（装箱）基本数据类型 —> 包装类：① 使用包装类的构造器 ② （建议）调用包装类的valueOf(xxx xx)

2.3 拆箱

拆箱：把包装类对象拆为基本数据类型

（拆箱）包装类–>基本数据类型：调用包装类的xxxValue()

转为基本数据类型，一般是因为需要运算，Java中的大多数运算符是为基本数据类型设计的。比较、算术等

包装对象---->基本数值

Integer obj = new Integer(4);
int num1 = obj.intValue();

【案例1】

现在有一个包装类对象，如下：

//（拆箱）包装类-->基本数据类型：
@Test
public void test2(){
    Integer ii1=new Integer(10);    //包装类对象

}

让包装类对象加一，但现在是对象，对象加一没有意义，就得将它转化为基本数据类型才可以加一。

Integer对应的基本数据类型是Int，所以是intvalue。

image.png

此时i就是一个基本数据类型了，可以进行加一运算了。如下：

//（拆箱）包装类-->基本数据类型：
@Test
public void test2(){
    Integer ii1=new Integer(10);    //包装类对象
    int i=ii1.intValue();
    i=i+1;
    System.out.println(i);

}

输出结果：

image.png

【案例2】

当然，Float类型也一样。

Float对应基本数据类型是float，所以是floatValue。

比如：

//（拆箱）包装类-->基本数据类型：
@Test
public void test2(){

    Float ff1=new Float(12.3F);	//浮点类型
    float f=ff1.floatValue();
    f=f+2;
    System.out.println(f);
}

输出结果：

image.png

【案例3】

Boolean布尔类型也是一样。

Boolean对应的是基本数据类型的boolean，所以是booleanValue()。

比如：

//（拆箱）包装类-->基本数据类型：
@Test
public void test2(){

    Boolean b2=Boolean.valueOf(true);   //布尔类型
    boolean b=b2.booleanValue();

}

（拆箱）包装类–>基本数据类型：调用包装类的xxxValue()

2.4 自动装箱与拆箱

自动装箱与拆箱：

由于我们经常要做基本类型与包装类之间的转换，从JDK5.0开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

注意：只能与自己对应的类型之间才能实现自动装箱与拆箱。

Integer i = 1;
Double d = 1;//错误的，1是int类型

【案例1-自动装箱】

🌱代码

package yuyi03;

public class WrapperTest {
    //jdk5.0新特性：自动装箱、自动拆箱。
    @Test
    public void test4(){
        //自动装箱：基本数据类型 ---> 包装类
        //int类型
        int i1=10;
        Integer ii1=i1; //右边i1是基本数据类型，左边ii1是引用数据类型，右边直接赋给左边（自动装箱）
        System.out.println(ii1.toString());
        
        Integer ii2=i1+1;   //右边i1+1变成11，然后再自动装箱到左边ii2
        System.out.println(ii2);
        

        //其他类型
        Boolean bb1=true;   //自动装箱
        
        Float f1=12.3F;     //自动装箱
    }

}

🍺输出结果

image.png

【案例2-自动拆箱】

🌱代码

package yuyi03;

public class WrapperTest {
    //jdk5.0新特性：自动装箱、自动拆箱。
    @Test
    public void test4(){
        //自动装箱：基本数据类型 ---> 包装类
        //int类型
        int i1=10;
        Integer ii1=i1; //右边i1是基本数据类型，左边ii1是引用数据类型，右边直接赋给左边（自动装箱）

        //其他类型
        Boolean bb1=true;   //自动装箱
        
        Float f1=12.3F;     //自动装箱


        //自动拆箱：包装类-->基本数据类型
        int i2=ii1;     //右边ii1是一个对象，左边i2是一个基本数据类型的变量。（自动拆箱）

        boolean b1=bb1;	//自动拆箱
    }

}

🗳️Tips

Integer ii1=i1;

右边i1是基本数据类型，左边ii1是引用数据类型，右边直接赋给左边（自动装箱）。

这里可以理解为“语法糖”，就是一个小的语法特性，似乎不太满足语法正规的要求，但是这样的写法又很轻巧、简洁。

其实底层它调用的还是之前说的方法。

比如现在我们看一下test4()的字节码文件，比如装箱：

image.png

所以，本质上还是调用包装类的valueOf(xxx xx)进行装箱的，只不过现在封装了一下。

拆箱也一样，如下：

image.png

所以，本质上还是调用包装类的xxxValue()进行拆箱的，只不过现在封装了一下。

有了这样一个新特性之后，似乎都感受不到包装类和基本数据类型有什么区别，直接就赋值用了。

这确实有利于开发的效率，不用过多关注它们相互转化的事情了。

2.5 注意

这里再说一个容易出错的地方。

既然变成对象了，初始化值也就不一样了。

【案例1】

🌱代码

package yuyi03;

public class WrapperTest {
    //注意
    @Test
    public void test3(){
        Account account=new Account();
        System.out.println(account.isFlag1);    //基本数据类型，默认值false
        System.out.println(account.isFlag2);    //默认值null
    }
}

class Account{
    //成员变量：有默认值
    boolean isFlag1;
    Boolean isFlag2;
}

🍺输出结果

image.png

🗳️Tips

boolean类型与Booleaan类型的默认值不一样。

【案例2】

🌱代码

package yuyi03;

public class WrapperTest {
    //注意
    @Test
    public void test3(){
        Account account=new Account();
        System.out.println(account.balance1);   //0.0
        System.out.println(account.balance2);   //null
    }

}

class Account{
    //成员变量：有默认值
    double balance1;    //基本数据类型，若是0.0可以表示账户余额为0，没有钱
    Double balance2;    //包装类，默认值是null，可以理解为这个账户的余额一开始没有初始化，后期new或者valueOf赋了一个值，若是0.0，可以理解为余额这个对象被初始化了，只不过初始化之后没有往里面放钱，或者花光了。所以这里可以区分是没有初始化还是账户没有钱
}

🍺输出结果

image.png

🗳️Tips

①double balance1;

基本数据类型，若是0.0可以表示账户余额为0，没有钱。

②Double balance2;

包装类，默认值是null，可以理解为这个账户的余额一开始没有初始化。

后期new或者valueOf赋了一个值，若是0.0，可以理解为余额这个对象被初始化了，只不过初始化之后没有往里面放钱，或者花光了。

所以这里可以区分是没有初始化还是账户没有钱。

原来使用基本数据类型变量的位置，改成包装类以后，对于成员变量来说，其默认值变化了！

2.6 代码

整体代码留下啦。

🌱代码

package yuyi03;

import org.junit.Test;

/**
 * ClassName: WrapperTest
 * Package: yuyi03
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/12/8 0008 10:04
 */
public class WrapperTest {
    //把基本数据类型包一下，让它具备类的特征，里面很多方法就可以去使用了
    /*
    * （装箱）基本数据类型 ---> 包装类：① 使用包装类的构造器 ② （建议）调用包装类的valueOf(xxx xx)
    * */
    @Test
    public void test1(){
        int i1 = 10;  //创建一个int型的变量  基本数据类型
        Integer ii1=new Integer(i1);    //包装起来了，具备了类的特征  对象
        System.out.println(ii1);    //结果是数据，不是地址

        float f1=12.3F;
        f1=32.2f;
        Float ff1=new Float(f1);
        System.out.println(ff1.toString());

        String s1="32.4";   //“ ” 的里面还是一个float或者double类型的
        Float ss1=new Float(s1);
        System.out.println(s1);

        /*s1="abc";
        Float ss2=new Float(s1);    //异常：NumberFormatException*/

        boolean b1=true;
        Boolean bb1=new Boolean(b1);
        System.out.println(bb1);

        String s2="false";
        s2="False123";
        s2="True";
        Boolean bb2=new Boolean(s2);
        System.out.println(bb2);

        //推荐使用
        //Integer类型
        int i2=10;
        Integer ii2= Integer.valueOf(i2);
        System.out.println(ii2);

        //Boolean类型
        Boolean b2=Boolean.valueOf(true);
        System.out.println(b2);

        //Float类型
        Float f2=Float.valueOf(12.3F);
        System.out.println(f2);

    }

    //（拆箱）包装类-->基本数据类型：调用包装类的xxxValue()
    @Test
    public void test2(){
        Integer ii1=new Integer(10);    //包装类对象
        int i=ii1.intValue();
        i=i+1;
        System.out.println(i);

        Float ff1=new Float(12.3F); //浮点类型
        float f=ff1.floatValue();
        f=f+2;
        System.out.println(f);

        Boolean b2=Boolean.valueOf(true);   //布尔类型
        boolean b=b2.booleanValue();

    }

    //注意
    @Test
    public void test3(){
        Account account=new Account();
        System.out.println(account.isFlag1);    //基本数据类型，默认值false
        System.out.println(account.isFlag2);    //默认值null

        System.out.println(account.balance1);   //0.0
        System.out.println(account.balance2);   //null
    }

    //jdk5.0新特性：自动装箱、自动拆箱。
    @Test
    public void test4(){
        //自动装箱：基本数据类型 ---> 包装类
        int i1=10;
        Integer ii1=i1; //右边i1是基本数据类型，左边ii1是引用数据类型，右边直接赋给左边（自动装箱）
        System.out.println(ii1.toString());

        Integer ii2=i1+1;   //右边i1+1变成11，然后再自动装箱到左边ii2
        System.out.println(ii2);

        Boolean bb1=true;   //自动装箱

        Float f1=12.3F;     //自动装箱

        //自动拆箱：包装类-->基本数据类型
        int i2=ii1;     //右边ii1是一个对象，左边i2是一个基本数据类型的变量。（自动拆箱）

        boolean b1=bb1; //自动拆箱
    }

}

class Account{
    //成员变量：有默认值
    boolean isFlag1;
    Boolean isFlag2;

    double balance1;    //基本数据类型，若是0.0可以表示账户余额为0，没有钱
    Double balance2;    //包装类，默认值是null，可以理解为这个账户的余额一开始没有初始化，后期new或者valueOf赋了一个值，若是0.0，可以理解为余额这个对象被初始化了，只不过初始化之后没有往里面放钱，或者花光了。所以这里可以区分是没有初始化还是账户没有钱
}

🍺输出结果

img

（3） 基本数据类型、包装类与字符串String间的转换

3.1 基本数据类型、包装类 -> String类型

基本数据类型、包装类 —> String类型：

① 调用String的重载的静态方法valueOf(xxx xx) ;

② 基本数据类型的变量 + “”

3.1.1 方法一

🍻调用String的重载的静态方法valueOf(xxx xx)

【案例1】

现在有一个基本数据类型i1，如下：

package yuyi03;

import org.junit.Test;

public class WrapperTest1 {
    //基本数据类型、包装类 ---> String类型：① 调用String的重载的静态方法valueOf(xxx xx) 
    public void test1(){
        int i1=10;

    }
}

既然转换成String类型，那就用String里面的方法（在后者找方法），如下：

image.png

直接将i1往里面写即可。

🌱代码

public class WrapperTest1 {
    //基本数据类型、包装类 ---> String类型：① 调用String的重载的静态方法valueOf(xxx xx) 
    @Test
    public void test1(){
        int i1=10;  //基本数据类型
        String str1 = String.valueOf(i1); //转化为String类型
        System.out.println(str1);   //"10"
    }
}

🍺输出结果

image.png

控制台输出没有显示双引号，其实是存在的。

【案例2】

再来看boolean类型转换为String类型，一样的道理。

🌱代码

package yuyi03;

import org.junit.Test;

public class WrapperTest1 {
    //基本数据类型、包装类 ---> String类型：① 调用String的重载的静态方法valueOf(xxx xx) 
    @Test
    public void test1(){
        boolean b1=true;
        String str2 = String.valueOf(b1);   //转化为String类型
        System.out.println(str2);
    }
}

🍺输出结果

image.png

【案例3】

刚才用的都是基本数据类型，也可以是对应包装类的对象。

🌱代码

public class WrapperTest1 {
    //基本数据类型、包装类 ---> String类型：① 调用String的重载的静态方法valueOf(xxx xx) 
    @Test
    public void test1(){
        boolean b1=true;
        Boolean b2=b1;  //自动装箱
        String str2 = String.valueOf(b1);   //转化为String类型
        String str3 = String.valueOf(b2);
        System.out.println(str2);
        System.out.println(str3);
    }
}

🍺输出结果

image.png

3.1.2 方法二

🍻基本数据类型的变量 + ""

基本数据类型和字符串可以做连接运算，连接之后结果还是一个字符串。

🌱代码

package yuyi03;

import org.junit.Test;

public class WrapperTest1 {
    //基本数据类型、包装类 ---> String类型：② 基本数据类型的变量 + ""
    @Test
    public void test1(){
        int i1=10;  //基本数据类型

        boolean b1=true;

        //方式2：直接的方式，基本数据类型的变量 + ""
        String str4=i1+"";  //基本数据类型和字符串可以做连接运算，连接之后结果还是一个字符串
        String str5=b1+"";
    }
}

3.2 String类型->基本数据类型、包装类

🍻String类型 —> 基本数据类型、包装类: 调用包装类的静态方法parseXxx()

比如在客户端上，客户填了很多信息，发送给后台，后台发送给客户端都可以使用json格式（本质上是一种特殊格式的字符串）的数据，传送来的时候都可以认为是具体的字符串，发送给后台的时候，需要把数据都获取出来，然后再写入相应的数据库中。

当我们把数据都发送到后台，后台读取到的就是字符串，但是当我们要存入数据库中的时候，所以需要将字符串转化为基本数据类型，方便存储。

【案例1】

前者转化为后者，去后者里面找方法。

基本数据里面没有方法啊，所以只能找包装类了。

🌱代码

package yuyi03;

import org.junit.Test;

public class WrapperTest1 {

    //String类型 ---> 基本数据类型、包装类: 调用包装类的静态方法：parseXxx()
    @Test
    public void test2(){
        String s1="123";
        int i1=Integer.parseInt(s1);    //将String类型的s1转化为int类型的i1
        System.out.println(i1+10);
    }

}

🍺输出结果

image.png

【案例2】

再举个例子。

🌱代码

package yuyi03;

import org.junit.Test;

public class WrapperTest1 {

    //String类型 ---> 基本数据类型、包装类: 调用包装类的静态方法：parseXxx()
    @Test
    public void test2(){
        String s2="true";
        boolean b1=Boolean.parseBoolean(s2);
        System.out.println(b1);
    }

}

🍺输出结果

image.png

【案例3】

有个特殊情况。

🌱代码

package yuyi03;

import org.junit.Test;

public class WrapperTest1 {

    //String类型 ---> 基本数据类型、包装类: 调用包装类的静态方法：parseXxx()
    @Test
    public void test2(){
        //特别的
        String s3="123a";
        int i2=Integer.parseInt(s3);	//NumberFormatException异常
    }

}

爆出异常：

image.png

3.3 代码

整体代码留下啦。

🌱代码

package yuyi03;

import org.junit.Test;

/**
 * ClassName: WrapperTest1
 * Package: yuyi03
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/12/11 0011 10:06
 */
public class WrapperTest1 {
    //基本数据类型、包装类 ---> String类型：① 调用String的重载的静态方法valueOf(xxx xx) ; ② 基本数据类型的变量 + ""
    @Test
    public void test1(){
        //方式1：调用String的重载的静态方法valueOf(xxx xx)
        int i1=10;  //基本数据类型
        String str1 = String.valueOf(i1); //转化为String类型
        System.out.println(str1);   //"10"

        boolean b1=true;
        Boolean b2=b1;  //自动装箱
        String str2 = String.valueOf(b1);   //转化为String类型
        String str3 = String.valueOf(b2);
        System.out.println(str2);
        System.out.println(str3);

        //方式2：直接的方式，基本数据类型的变量 + ""
        String str4=i1+"";  //基本数据类型和字符串可以做连接运算，连接之后结果还是一个字符串
        String str5=b1+"";
    }


    //String类型 ---> 基本数据类型、包装类: 调用包装类的静态方法：parseXxx()
    @Test
    public void test2(){
        String s1="123";
        int i1=Integer.parseInt(s1);    //将String类型的s1转化为int类型的i1
        System.out.println(i1+10);

        String s2="true";
        boolean b1=Boolean.parseBoolean(s2);
        System.out.println(b1);

        //特别的
        String s3="123a";
        //int i2=Integer.parseInt(s3);    //异常：NumberFormatException
    }

}

🍺输出结果

image.png

3.4 总结

<1> 基本数据类型转为字符串

方式1：调用字符串重载的valueOf()方法

int a = 10;
//String str = a;//错误的

String str = String.valueOf(a);

方式2：更直接的方式

int a = 10;

String str = a + "";

<2> 字符串转为基本数据类型

方式1：除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型，例如：

  • public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
  • public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
  • public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。

方式2：字符串转为包装类，然后可以自动拆箱为基本数据类型

  • public static Integer valueOf(String s)：将字符串参数转换为对应的Integer包装类，然后可以自动拆箱为int基本类型
  • public static Long valueOf(String s)：将字符串参数转换为对应的Long包装类，然后可以自动拆箱为long基本类型
  • public static Double valueOf(String s)：将字符串参数转换为对应的Double包装类，然后可以自动拆箱为double基本类型

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

方式3：通过包装类的构造器实现

int a = Integer.parseInt("整数的字符串");
double d = Double.parseDouble("小数的字符串");
boolean b = Boolean.parseBoolean("true或false");

int a = Integer.valueOf("整数的字符串");
double d = Double.valueOf("小数的字符串");
boolean b = Boolean.valueOf("true或false");

int i = new Integer(“12”);

☕其他方式小结：

String 与 基本数据类型、包装类之间的转换：

  • 基本数据类型、包装类 —> String类型：① 调用String的重载的静态方法valueOf(xxx xx) ; ② 基本数据类型的变量 +""
  • String类型 —> 基本数据类型、包装类: 调用包装类的静态方法：parseXxx()

🚗图
image.png

三、 包装类的其它API

（1） 数据类型的最大最小值

Integer.MAX_VALUE和Integer.MIN_VALUE
    
Long.MAX_VALUE和Long.MIN_VALUE
    
Double.MAX_VALUE和Double.MIN_VALUE

（2）字符转大小写

Character.toUpperCase('x');

Character.toLowerCase('X');

（3） 整数转进制

Integer.toBinaryString(int i) 
    
Integer.toHexString(int i)
    
Integer.toOctalString(int i)

（4） 比较的方法

Double.compare(double d1, double d2)
    
Integer.compare(int x, int y)

四、 包装类对象的特点

（1）包装类缓存对象

包装类缓存对象
Byte-128~127
Short-128~127
Integer-128~127
Long-128~127
Float没有
Double没有
Character0~127
Booleantrue和false
Integer a = 1;
Integer b = 1;
System.out.println(a == b);//true

Integer i = 128;
Integer j = 128;
System.out.println(i == j);//false

Integer m = new Integer(1);//新new的在堆中
Integer n = 1;//这个用的是缓冲的常量对象，在方法区
System.out.println(m == n);//false

Integer x = new Integer(1);//新new的在堆中
Integer y = new Integer(1);//另一个新new的在堆中
System.out.println(x == y);//false

Double d1 = 1.0;
Double d2 = 1.0;
System.out.println(d1==d2);//false 比较地址，没有缓存对象，每一个都是新new的

（2）类型转换问题

Integer i = 1000;
double j = 1000;
System.out.println(i==j);//true  会先将i自动拆箱为int，然后根据基本数据类型“自动类型转换”规则，转为double比较

Integer i = 1000;
int j = 1000;
System.out.println(i==j);//true 会自动拆箱，按照基本数据类型进行比较

Integer i = 1;
Double d = 1.0
System.out.println(i==d);//编译报错

（3）包装类对象不可变

public class TestExam {
	public static void main(String[] args) {
		int i = 1;
		Integer j = new Integer(2);
		Circle c = new Circle();
		change(i,j,c);
		System.out.println("i = " + i);//1
		System.out.println("j = " + j);//2
		System.out.println("c.radius = " + c.radius);//10.0
	}
	
	/*
	 * 方法的参数传递机制：
	 * （1）基本数据类型：形参的修改完全不影响实参
	 * （2）引用数据类型：通过形参修改对象的属性值，会影响实参的属性值
	 * 这类Integer等包装类对象是“不可变”对象，即一旦修改，就是新对象，和实参就无关了
	 */
	public static void change(int a ,Integer b,Circle c ){
		a += 10;
//		b += 10;//等价于  b = new Integer(b+10);
		c.radius += 10;
		/*c = new Circle();
		c.radius+=10;*/
	}
}
class Circle{
	double radius;
}

五、 习题

（1）练习1

🌋题目描述

利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，并输出学生成绩等级。

  • 提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的长度。而向量类java.util.Vector可以根据需要动态伸缩。
  • 1、创建Vector对象：Vector v=new Vector();
  • 2、给向量添加元素：v.addElement(Object obj); //obj必须是对象
  • 3、取出向量中的元素：Object obj=v.elementAt(0);
    • 注意第一个元素的下标是0，返回值是Object类型的。
  • 4、计算向量的长度：v.size();
  • 5、若与最高分相差10分内：A等；20分内：B等；30分内：C等；其它：D等

Vector作为一个容器，在使用的时候，添加元素addElement和获取元素elementAt，它的obj必须是对象。

所以往容器里面放基本数据类型就不行了，得装箱；

而将数据从容器里面取出来的时候，让这个元素与最高分比较，用差值判断等级，这时候就需要拆箱操作。

🎲分析

1、首先分析一下，大致有以下几个步骤。

public class ScoreTest {
    public static void main(String[] args) {
        //1.创建Vector对象：Vector v=new Vector();
        Vector v=new Vector();

        Scanner scanner=new Scanner(System.in);

        //2.从键盘获取多个学生成绩，存放到容器v中 （以负数代表输入结束）
        while(true){    //或 for(;;)

        }

        //3.获取学生成绩的最大值（计算最高分）

        //4.依次获取v中每个学生成绩，与最高分进行比较，获取学生等级，并输出

        scanner.close();
    }
}

2、装箱与拆箱

装箱操作两种方式：
image.png

拆箱操作两种方式：
image.png

3、Vector相关函数

【addElement】

给向量添加元素：v.addElement(Object obj); //obj必须是对象

image.png

E是后边要说的“泛型”，这里先看作Object。

【elementAt】

取出向量中的元素：Object obj=v.elementAt(0);

注意第一个元素的下标是0，返回值是Object类型的。

elementAt()里面是索引，其实Vevtor底层还是数值，只不过将数组封装起来，放入一个类里面体现了。

image.png

🌱代码

package yuyi03;

import java.util.Scanner;
import java.util.Vector;

/**
 * ClassName: ScoreTest
 * Package: yuyi03
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/12/13 0013 15:51
 */
public class ScoreTest {
    public static void main(String[] args) {
        //1.创建Vector对象：Vector v=new Vector();
        Vector v=new Vector();

        Scanner scanner=new Scanner(System.in);

        int maxScore=0; //在有效范围内，取一个最小值，来当最高分


        //2.从键盘获取多个学生成绩，存放到容器v中 （以负数代表输入结束）
        while(true){    //或 for(;;)
            System.out.print("请输入学生成绩（以负数代表输入结束）：");
            int intScore=scanner.nextInt(); //从键盘拿到数据（基本数据类型）

            if(intScore<0){
                break;
            }

            //装箱操作方式一
            /*//装箱：int-->Integer对象
            Integer score=Integer.valueOf(intScore);

            //添加成绩到容器v中
            v.addElement(score); //参数是Object类型，score以多态的方式传入*/


            //装箱操作方式二（jdk5.0之后 自动装箱）
            v.addElement(intScore);


            //3.获取学生成绩的最大值（计算最高分）
            if(maxScore<intScore){
                maxScore=intScore;
            }

        }
        System.out.println("最高分为： "+maxScore);

        //4.依次获取v中每个学生成绩，与最高分进行比较，获取学生等级，并输出
        for (int i = 0; i < v.size(); i++) {    //计算向量v的长度：v.size()
            Object objScore=v.elementAt(i); //从v中取出的元素是Object类型

            /*//拆箱方法一
            Integer integerScore= (Integer) objScore;   //强转
            int score=integerScore.intValue();*/

            //拆箱方法二
            int score= (Integer) objScore;  //先将objScore转化为Integer，然后自动拆箱为int类型的score

            char grade=' '; //此时if-else结构中有else结束，就是无论如何最终grade都会有值，所以这里可以赋值为' '，也可以不赋值（只要确保有值就行）
            if(maxScore-score <= 10){
                grade='A';
            } else if (maxScore - score<=20) {
                grade='B';
            }else if (maxScore - score<=30) {
                grade='C';
            }else {
                grade='D';
            }

            System.out.println("Student "+ i +" score is " + score + " grade is " + grade);
        }

        scanner.close();
    }
}

🍺输出结果

image.png

（2）面试题

2.1 面试题1

输出结果是？

//说明：如果赋值的值在[-128,+127]范围内，则Integer对象使用的是IntegerCache中数组cache中的元素

public class InterviewTest1 {
    public static void main(String[] args) {

        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j); //false 两个对象地址肯定不一样

        //底层都会调用Integer的valueOf()
        Integer m = 1; //自动的装箱
        Integer n = 1;
        System.out.println(m == n);//true

        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);//false

    }

}

☕分析

看一下字节码文件：

image.png

所以“自动装箱”，其实就是调用valueOf()。

现在来看一下valueOf()具体的怎么做的。

Ctri+N调出搜索框，然后输入Integer，如下：

image.png

然后Ctrl+F12，输入valueOf，如下：

image.png

得出如下代码：

image.png

可以看一下i的赋值，最大值是127，如下：

image.png

最小值是-128。

所以当i的取值是-128 ~ +127的时候，从现有的数组里面取的。如下：

image.png

所以，若赋值的是128，那么它们的地址值不同，结果就是false，如下：

image.png

那么若是范围在【-128,127】的时候，是从现有数组中取，看一下数组cache：

image.png

所以这里传入的是1，取的都是数组中已经new好的Integer里面值是1的位置。

它们用的是同一个对象，所以地址值相同。如下：

image.png

🗳️这样做的好处是什么呢？

一方面直接拿过来用，比较快；另一方面，节省了内存空间，因为平时在用Integer的时候，[-128,+127]用的场景比较多，当需要使用的时候，直接拿现成的对象用即可，用不着每次都new一个，节省了时间。

这种设计模式叫“享元”，享–>共享（把大家都可以使用的公共数据都放到一个结构里面，谁需要用拿来用即可）

这个在笔试题中考的很多

还有这些也使用了享元的设计模式，如下：
image.png

若是将Integer换成Byte，若两个Byte都是1，==之后结果是true；若是128，结果就是false。

Character是字符，范围是[0，127]。

Boolean是布尔类型，只有两个值true和false。

用自动装箱的方式，范围内两个比较结果都是true，出了范围就是false。

Float和Double有小数点，没办法指定。

🍺输出结果

image.png

2.2 面试题2

输出结果是？

package yuyi03.interview;

/**
 * ClassName: InterviewTest2
 * Package: yuyi03.interview
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/12/14 0014 0:08
 */
public class InterviewTest2 {
    public static void main(String[] args) {
        //题目1：
        int i = 10;
        double d = 10.2;
        System.out.println(i == d);	//地址不相同，结果为false
        
        //题目2：
        Integer i1 = 10;
        Double d1 = 10.2;
        //System.out.println(i1 == d1);	//编译报错

        //题目3：
        Integer m = 1000;
        double n = 1000;
        System.out.println(m == n);//true

        //题目4：
        Integer x = 1000;
        int y = 1000;
        System.out.println(x == y);//true
    }
}

☕分析

题目2：

System.out.println(i1 == d1);

编译报错。

在Java里面，==可以比较引用数据类型，可以比较地址。

但是前提是，两者类型要相同，或者是子父类的关系，此时Integer和Double是两个并列的类，Double继承于Number，Integer也继承于Number，所以Integer和Double是Number的两个并列的子类，没有任何关系。

编译的时候都过不了。如下：

image.png

题目三：

可以看到编译器没有报错，如下：

image.png

这里明显比较的时候是对n有一个“拆箱”操作，因为如果是装箱的话，double变成Double类型 ，Integer和Double比较，就是第二题，编译都无法通过。

所以拆箱操作之后，Integer变成int，m与n两个基本数据类型类型比较，都是1000，结果就是true。

这里为什么是拆箱操作而不是装箱呢？

这就是设计的时候这样规定的，当出现基本数据类型和包装类的时候，优先选择拆箱。

因为拆箱的成本低，将对象拆成基本数据类型去比较，速度上更快。要是将基本数据类型装箱成包装类，就得将它变成对象，成本更高。

可以看一下字节码文件：

image.png

题目四：

image.png

和题目三类似，这里比较的时候也会有“拆箱”操作，Integer类型的x拆成int类型，然后与y比较，结果为true。

若是装箱操作，int类型的y装箱为Integer类型，此时1000超出了[-128,127]范围，所以x和y它们都是新创建的对象，结果就是false了。

看一下字节码文件：

image.png

🍺输出结果

image.png

2.3 面试题3

输出结果是？

package yuyi03.interview;

/**
 * ClassName: InterviewTest3
 * Package: yuyi03.interview
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/12/14 0014 10:41
 */
public class InterviewTest3 {
    public static void main(String[] args) {
        Object o1 = true ? new Integer(1) : new Double(2.0);
        System.out.println(o1);//1.0


        Object o2;
        if (true)
            o2 = new Integer(1);
        else
            o2 = new Double(2.0);
        System.out.println(o2);//1
    }
}

☕分析

这里有一个三元运算符，如下：

image.png

很明显，问好前面是true，所以返回的是前者new Integer(1)，即：Object o1 = new Integer(1) ;

此时输出结果是1.0，为啥呢？

其实三元运算符有一个兼容问题，返回值类型要相同，还有字符强转功能，返回值类型为两个返回值中类型精度更高的那个类型。

所以，此时的1被转换为了double类型，所以输出的是1.0。

若是使用if-else结构，很显然结果就是1。如下：

image.png

🍺输出结果

image.png

本节重点是关注基本数据类型、包装类、String类型三者之间的转换。

雨翼轻尘
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Wrappers 方法释义
m0_51985332的博客
12-22 567
Wrappers 方法释义
Java面向 对象--Object类和包装类的使用
༺ཌ༈君纤༈ད༻
03-17 123
本篇博客介绍Java面向对象中Object类和包装类的用法...
Java中包装类Wrapper的使用
BravoNathan的博客
12-23 1046
Java中包装类Wrapper的使用 1. 让基本数据类型也有类的特征（封装在类中） （红字是包装类名字与基本数据类型有区别） 它们的父类都为Number 基本类型、包装类、String类之间的相互转换 2. 基本数据类型转换为包装类：***调用包装类的构造器*** public class WrapperTest { ／／基本数据类型---＞包装类：调用包装类的构造器 @Test public void test1(){ int num1 = 10; //System.out.print1n(n
wrapper的基础知识和常用方法
最新发布
XYAX104的博客
07-23 484
条件构造器关系介绍 ：上图绿色框为抽象类abstract蓝色框为正常class类，可new对象黄色箭头指向为父子类关系，箭头指向为父类wapper介绍 ：Wrapper ： 条件构造抽象类，最顶端父类AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件QueryWrapper ： Entity 对象封装操作类，不是用lambda语法UpdateWrapper ： Update 条件封装，用于Entity对象更新操作。
Java-包装类(Wrapper)的使用（一篇讲透）
weixin_52533007的博客
05-21 2816
包装类的使用前言一、概述二、作用三、使用1. 基本数据类型---->包装类的实例（装箱）2. 包装类---->基本数据类型（拆箱）3. String---->基本数据类型/包装类4. 基本数据类型/包装类---->String5. 转换图四、经典题目 前言 本博主将用CSDN记录软件开发求学之路上亲身所得与所学的心得与知识，有兴趣的小伙伴可以关注博主！ 也许一个人独行，可以走的很快，但是一群人结伴而行，才能走的更远！让我们在成长的道路上互相学习，欢迎关注！ 一、概述 针对八种
Java中包装类(Wrapper)的使用
MrYushiwen的博客
11-17 750
一.8种基本数据类型对应的包装类 针对八种基本数据类型定义相应的引用类型——包装类（封装类） 有了类的特点，就可以调用类中的方法 以下是8种基本数据类型对应的其包装类： 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float double Double boolean Boolean char Character 二.包装类与基本数据类型之间的转换（拆箱与装箱、自动拆装箱） 1.
Java Service Wrapper使用说明
10-09
Java Service Wrapper使用说明
Java面向对象（高级）- 包装类（wrapper）的使用
12-14
总结，包装类在Java中扮演着重要角色，它们使得基本数据类型能够适应面向对象的环境，提供了更丰富的功能，同时也优化了性能。理解和熟练使用包装类及其转换方法，对于编写高质量的Java代码至关重要。
Java学习资料-包装类
06-14
在Java编程语言中，包装类（Wrapper Classes）扮演着至关重要的角色，它们是Java为每种基本数据类型提供的一种对象表示形式。这些包装类使得基本数据类型能够参与到面向对象的编程中，如方法参数传递、集合操作等。...
Java常用类-包装类(Wrapper)简单介绍
nmvc01的博客
01-28 3778
目录前言1、包装类(Wrapper) 前言 本文主要介绍java中的包装类 1、包装类(Wrapper) Java是面向对象的编程语言，但它也包含了8种基本数据类型，这8种基本数据类型不支持面向对象的编程机制，基本数据类型的数据也不具备“对象”的特性：没有成员变量、方法可以被调用。 针对八种基本数据类型定义相应的引用类型—包装类（封装类）； 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象。 自动装箱与自动拆箱： 装箱：基本数据类型包装成包装类的实例 通过包装类的构造器实现： in
ordrin-wrapper:Java ordr.in 包装器
06-25
1. **Java编程**：作为主要的开发语言，Java提供了面向对象的特性，使得创建包装器类变得可能。开发者可以利用其丰富的库和强大的类型系统来构建高效且健壮的API客户端。 2. **API交互**：包装器的核心功能是与or....
mybatis-plus中wrapper的用法（详细）
热门推荐
DayDayUp
09-03 11万+
mybatis-plus中wrapper的用法，ge、le、ne、eq、及多表查询自写sql
&Java中包装类（wrapper）的使用 &基本数据类型、包装类、String三者之间的相互转换
m0_58052874的博客
02-25 524
8种基本数据类型对应的包装类 基本数据类型进行包装后，有了类的特点，就可以调用类中的方法，Java才是真正的面向对象 基本类型、包装类与String类间的转换 基本数据类型 --->包装类： 方式1：5.0 新特性：自动装箱 int num1 = 10; Integer integer = num1; 方式2：调用包装类的构造器 public class WrapperTest { public static void main(String[] ar...
包装类(Wrapper)的使用
weixin_52629592的博客
11-18 829
1.针对8种基本数据类型定义相应的引用类型--包装类(封装类),使得基本数据类型的变量具有类的特征 2.有了类,就可以调用类中的方法,java才是真正的面向对象 3.基本数据类型 包装类 byte Byte short Short int Integer long Long float...
Java Wrapper
qingsongxyz的博客
05-23 287
Java Wrapper 一、包装类 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float double Double char Character boolean Boolean 二、自动装箱与拆箱 以int和Integer为例： //自动装箱,将int转换为Interger Integer integer = 1; //自动拆箱,将Integer转换为int int n
包装类Wrapper（封装类）的使用
卓汶的博客
10-21 1080
包装类Wrapper（封装类）的使用 包装类（封装类）是针对八种基本数据类型定义相应的引用。 让java中的基本数据类型有了类的特点和功能，就可以调用类中的方法，java才是真正的面向对象。 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float doble Double boolean Boolean char Character 数值型的（Byte、Short、Integer、L
Java八大Wrapper类
Bejpse的博客
05-17 446
Java八大Wrapper类 包装类 针对八种基本数据类型相应的引用类型 基本数据类型 包装类 boolean Boolean char Character byte Byte short Short int Integer long Long float Float double Double 有类的特点, 可以调用类方法 包装类和基本数据类型转换 以int和Integer为例 jdk5前, 装箱: 基本数据类型->包装类型, 反之拆箱. jdk5之后, 自动装箱和拆箱 自动装箱底层调用的
Java Service Wrapper实践
weixin_33906657的博客
05-05 250
为什么80%的码农都做不了架构师？>>> ...
Java面向对象深入：包装类与静态方法解析
"Java面向对象深入，探讨包装类的通用方法和面向对象的高级特性" 在Java编程中，面向对象是核心概念之一，它包括了许多关键特性，如封装、继承、多态等。包装类是Java中将原始类型（primitive types）与对象之间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雨翼轻尘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值