第47章 包装类

作者：张子默

一、概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

二、装箱与拆箱

基本数据类型与对应的包装类对象之间来回转换的过程称为"装箱"与"拆箱"：

• 装箱：从基本类型转换为对应的包装类对象。
• 拆箱：从包装类对象转换为对应的基本类型。

用Integer和int为例：(看懂代码即可)

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

Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法
1
2

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

int num = i.intValue();
1

三、自动装箱与自动拆箱

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

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

四、基本类型与字符串之间的转换

基本类型转换String总共有三种方式

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

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

代码使用(仅以Integer类的静态方法parseXxx为例)，如：

public class Demo18WrapperParse {
    public static void main(String[] args) {
    	int num = Integer.parseInt("100");
    }
}
1
2
3
4
5

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

五、实例

• 装箱与拆箱

package com.zzm.day12.demo07;

/**
 * 用途：
 * 时间：2021/6/29 19:01
 * 创建人：张子默
 */

/*
装箱：把基本类型的数据，包装到包装类中(基本类型的数据->包装类)
    构造方法：
        Integer(int value)：构造一个新分配的 Integer 对象，它表示指定的 int 值。
        Integer(String s)：构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
            传递的字符串必须是基本类型的字符串，否则会抛出异常 "100" 正确 "a" 抛异常

    静态方法：
        static Integer valueOf(String s)：返回保存指定的 String 的值的 Integer 对象。
        static Integer valueOf(String s, int radix)：返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。
拆箱：在包装类中取出基本类型的数据(包装类->基本类型的数据)
    成员方法：
        int intValue()：以 int 类型返回该 Integer 的值。
 */
public class Demo01Integer {

    public static void main(String[] args) {
        // 装箱：把基本类型的数据，包装到包装类中(基本类型的数据->包装类)
        Integer in1 = new Integer(1); // 方法上有横线，说明方法过时了
        System.out.println(in1); // 1 重写了toString方法

        Integer in2 = new Integer("1");
        System.out.println(in2); // 1

        // 静态方法
        Integer in3 = Integer.valueOf(1);
        System.out.println(in3); // 1

        // Integer in4 = Integer.valueOf("a"); // NumberFormatException数字格式化异常
        Integer in4 = Integer.valueOf("1");
        System.out.println(in4); // 1

        // 拆箱：在包装类中取出基本类型的数据(包装类->基本类型的数据)
        int i = in1.intValue();
        System.out.println(i); // 1
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

• 自动装箱与自动拆箱

package com.zzm.day12.demo07;

import java.util.ArrayList;

/**
 * 用途：
 * 时间：2021/6/29 19:13
 * 创建人：张子默
 */

/*
自动装箱与自动拆箱：基本类型的数据和包装类之间可以自动的相互转换
JDK 1.5之后出现的新特性
 */
public class Demo02Integer {

    public static void main(String[] args) {
        /*
        自动装箱：直接把int类型的整数赋值给包装类
        Integer in = 1; // 就相当于 Integer in = new Integer(1);
         */
        Integer in = 1;

        /*
        自动拆箱：in是包装类，无法直接参与运算，可以自动转换为基本数据类型，再进行计算。
        in+2; // 就相当于 in.intValue() + 2;
        in = in.intValue() + 2 = 3; // 又是一个自动装箱
         */
        in = in + 2;

        ArrayList<Integer> list = new ArrayList<>();
        /*
        ArrayList集合无法直接存储整数，可以存储Integer包装类。
         */
        list.add(1); // --> 自动装箱 list.add(new Integer(1);

        int a = list.get(0); // -->自动拆箱 list.get(0).intValue();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

• 基本类型与字符串类型之间的转换

package com.zzm.day12.demo07;

/**
 * 用途：
 * 时间：2021/6/29 19:22
 * 创建人：张子默
 */

/*
基本类型与字符串类型之间的相互转换
    基本类型->字符串(String)
        1.基本类型的值+"" 最简单的方法
        2.使用包装类的静态方法toString(参数)，不是Object的toString()方法 重载
            String toString()：返回一个表示该 Integer 值的 String 对象。
        3.String类的静态方法valueOf(参数)
            static Integer valueOf(int i)：返回一个表示指定的 int 值的 Integer 实例。
    字符串(String)->基本类型
        使用包装类的静态方法parsexxx("数值类型的字符串");
            Integer类：static int parseInt(String s)
            Double类：static double parseDouble(String s)
 */
public class Demo03Integer {

    public static void main(String[] args) {
        // 基本类型->字符串(String)
        int i1 = 100;
        String s1 = i1 + "";
        System.out.println(s1 + 200); // 100200

        String s2 = Integer.toString(100);
        System.out.println(s2 + 200); // 100200

        String s3 = String.valueOf(100);
        System.out.println(s3 + 200); // 100200

        // 字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i - 10); // 90

        int a = Integer.parseInt("a"); // NumberFormatException
        System.out.println(a);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44