11-包装类

包装类是Java提供的一组类，专门用来创建8种基本数据类型对应的对象，一共8个包装类，存放在 java.lang包中。

包装类体系结构如下：

示例：

public class IntegerDemo {
    public static void main(String[] args) {
        // 定义一个字符串
        String str = "123";
        // 将字符串转换成整型
        int num = Integer.parseInt(str);
        System.out.println(num++); // 123
    }
}
1
2
3
4
5
6
7
8
9

装箱与拆箱

• 装箱：将基本数据类型转为对应的包装类对象，利用各个包装类的构造方法完成。
• 拆箱：将包装类对象转为对应的基本数据类型，利用Number类的xxxValue()方法完成（xxx表示基本数据类型的名称）。
• JDK1.5之前，使用手动方式进行装箱和拆箱的操作。
• JDK1.5之后，使用自动装箱(Autoboxing)和自动拆箱(Auto Unboxing)的操作。（所以我们使用的便利是拿编译器的辛苦换来的🤭）

示例：

public class TestBoxingAndUnboxing {
    public static void main(String[] args) {
        // 1、基本数据类型变为包装类,装箱
        // 通过传入基本类型数据,然后使用new关键字调用Integer类的构造方法,将其变为Integer类的对象intObj，整个过程为装箱操作。
        Integer intObj = new Integer(10);
        // 2、包装类变为基本类型,拆箱
        // 将包装类Integer类的对象intObj,还原为基本类型,并赋值给整型变量temp,整个过程为拆箱操作。
        int temp = intObj.intValue();
        System.out.println("整型变量temp的值为:" + temp);

        System.out.println("---------------分割线-----------------");

        int temp2 = 345;
        // 3、自动装箱
        //在编译阶段,编译器会自动将 intObj = temp2;  这条语句扩转为：intObj = intObj.valueOf(temp2);
        intObj = temp2;
        // 4、自动拆箱
        //在编译阶段,编译器会自动将  int temp3 = intObj;  这条语句扩转为： int temp3 = intObj.intValue();
        int temp3 = intObj;
        temp3++;
        System.out.println("整型变量temp3的值为:" + temp3);

        // 自动装箱
        Boolean boo = true;
        // 自动拆箱
        boolean flag = boo;
        System.out.println(flag && false);
    }
}
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

运行结果如下：

基本类型与字符串的转换

使用包装类的特点是将字符串变为指定的基本类型数据。

• 以Integer为例： public static int parseInt(String s);
• 以Double为例： public static int parseDouble(String s);
• 以Boolean为例： public static int parseBoolean(String s);

但是以上的操作方法形式对于字符类型(character)是不存在的。因为String类有一个charAt()方法，可以取得指定索引的字符。

示例：

public class Test3 {
    public static void main(String[] args) {
        // 定义一个字符串
        String str = "3.14";
        // 将字符串转为double
        double d = Double.parseDouble(str);
        System.out.println("d:" + d);

        //重新给字符串赋值
        str = "true";
        boolean flag = Boolean.parseBoolean(str);
        if (flag){
            System.out.println("条件满足!");
        }else{
            System.out.println("条件不满足!");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

运行结果如下：

将基本类型变为字符串

使用String类中的valueOf()方法。

示例：

public class Test3 {
    public static void main(String[] args) {
     int intValue = 100;
        // 将整型变量转换成字符串型
        String str = String.valueOf(intValue);
        System.out.println(str);

        double e = 2.718;
        // 将double变量转换成字符串型
        str = String.valueOf(e);
        System.out.println(str);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果如下：

Integer数值比较

public class Test {
    public static void main(String[] args) {
    	// 自动装箱,相当于 Integer.valueOf();
        Integer a = 200;
        Integer b = 200;
        Integer c = 100;
        Integer d = 100;
        int e = 200;
        System.out.println(a == b); // false
        System.out.println(c == d); // true
        // 先自动拆箱相当于Integer.intValue();,然后再判断是否相等
        System.out.println(b == e); // true
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

如果整型字面量的值在-128 到 127 之间，那么不会 new 新的 Integer 对象，而是直接引用常量池
中的 Integer 对象，所以 c = = d 的结果是 true，而 a = = b 的结果是 false。