包装类笔记

包装类

5.1 概述

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

5.2 Integer 类

• Integer 类概述
  包装一个对象中的原始类型 int 的值
• Integer 类构造方法及静态方法

    public static void main(String[] args) {
        Integer last1 = new Integer(10); //以前过时的创建方法
        Integer last2= new Integer("1234");  //也是过时的创建方法
        System.out.println(last1);  //10
        System.out.println(last2);  //1234

        //现在的Integer创建方式一般是用这个静态方法直接进行创建
        Integer now1 = Integer.valueOf(10);  //10
        Integer now2 = Integer.valueOf("4567");  //4567
        System.out.println(now1);
        System.out.println(now2);

        //包装类的进制转换
        /*
        * 下面这个也是一种静态方法
        * 主要作用是将这个里面传递的参数转化为一个自己定义的进制
        * */
        String binary= Integer.toBinaryString(10); //十进制
        String binary1= Integer.toOctalString(9); //八进制
        String binary2 = Integer.toHexString(17);//十六进制
        System.out.println(binary);//1010
        System.out.println(binary1);//11
        System.out.println(binary2);//11
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

其中这个方法是不全的，对于这个 parse 转化，我们可以又 parseInt 也可以有 Double. parseDouble，也可以有 Boolean. parseBoolean
同样对于这个 toXXXString 方法，我们也有一个总方法就是 toString 方法，这个方法可以我们自己自定义这个进制

        String binary3 = Integer.toString(3,2);
        String binary4 = Integer.toString(9,8);
        String binary5 = Integer.toString(10,9);
        System.out.println(binary3);
        System.out.println(binary4);
        System.out.println(binary5);
1
2
3
4
5
6

但是要注意这个 Double 类型虽然也有这个 toString 方法，但是却不能进行进制转化
有关于进制转化的可以看这个文章。一个是 obsidian 的内链，一个是博客的链接
[[二进制, 八进制, 和十六进制的输入和输出]]
博客

5.3 装箱与拆箱

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

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

用 Integer 与 int 为例：（看懂代码即可）
基本数值---->包装对象

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

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

int num = i.intValue ();

        int i = now1.intValue();
        int i2 = now2.intValue();
        byte a = now1.byteValue();
        byte b = now2.byteValue();
        System.out.println(i);
        System.out.println(i2);
        System.out.println(a);
        System.out.println(b);
1
2
3
4
5
6
7
8

对于这个装箱和拆箱的过程，其中拆箱其实就是对这个包装类的成员值变量进行了强制类型转化

    private final int value;
    public byte byteValue() {
        return (byte)value;
    }
1
2
3
4

对于这个装箱的过程，我们其实就是对这个包装类的内部成员进行赋值

	private final int value;
    public Integer(int value) {
        this.value = value;
    }
1
2
3
4

5.4 自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从 Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：
Integer i = 4;//自动装箱。相当于 Integer i = Integer.ValueOf (4);
i = i + 5;//等号右边：将 i 对象转成基本数值 (自动拆箱) i.intValue () + 5;
//加法运算完成后，再次装箱，把基本数值转成对象。

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

基本类型转换为 String

• 转换方式
• 方式一：直接在数字后加一个空字符串
• 方式二：通过 String 类静态方法 valueOf()
• 示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2
        //public static String valueOf(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

String 转换成基本类型

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

• public static byte parseByte(String s)：将字符串参数转换为对应的 byte 基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的 short 基本类型。
• 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 基本类型。

[!tip]

除了 Character 类之外，其他所有包装类都具有 parseXxx 静态方法可以将字符串参数转换为对应的基本类型；
为什么 Character 类没有呢
这是因为这些强制转化的参数都是字符串的类型
Character 类表示一个字符，而字符本身就是一个单个的字符，无法像整数或浮点数那样具有多个字符组成的表示形式。因此，从字符串中解析字符的需求不如解析整数或浮点数那样常见。
如果想将一个表示单个字符的字符串转换成 char 类型，可以使用 charAt 方法来提取其中的字符。例如：

String str = "A"; 
char c = str.charAt(0); 
System.out.println(c);  // 输出：A
1
2
3

代码使用（仅以 Integer 类的静态方法 parseXxx 为例）如：

• 转换方式
  • 方式一：先将字符串数字转成 Integer，再调用 valueOf ()方法
  • 方式二：通过 Integer 静态方法 parseInt ()进行转换
• 示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

[!warning]

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