Java025——包装类

一、包装类

Java为了能将基本数据类型视为对象进行处理，Java 提出了包装类的概念，它主要是将基本数据类型封装在包装类中，如 int 型的包装类 Integer、boolean 型的包装类 Boolean 等，这样便可以把这些基本数据类型转换为对象进行处理

二、Java 中的包装类及其对应的基本数据类型

包装类	对应基本数据类型
Byte	byte
Integer	int
Float	float
Character	char
Short	short
Long	long
Double	double
Boolean	boolean

三、Integer 类

3.1、int和Integer的区别

参考

class test {
    public static void main(String[] args) {
        int num1 = 10;
        Integer num2 = 10;
 		Integer num3 = new Integer(10);//或Integer num3 = new Integer(“10”);
        
        System.out.println(num1 == num2);
        System.out.println(num1 == num3);
    }
}

//运行结果
true
false

在Java中，int和Integer是两种表示整数的数据类型，具有以下区别：

1. 基本数据类型 vs 引用数据类型：

   • int是基本数据类型，用于表示整数值。它在内存中占据固定的内存空间，不需要进行对象实例化。
   • Integer是java.lang.Integer类的包装类，用于提供对int基本数据类型的封装。它是引用数据类型，需要进行对象实例化才能使用。

2. 空值（null）处理：

   • int是基本数据类型，不能为null，它没有默认值。
   • Integer是引用数据类型，可以为null。

3. 自动装箱和拆箱：

   • 自动装箱：Java提供了自动将int基本类型转换为对应的Integer对象的机制，称为装箱（boxing）。
   • 自动拆箱：Java提供了自动将Integer对象转换为对应的int基本类型的机制，称为拆箱（unboxing）。

4. 包装类提供的方法和功能：

   • Integer类作为引用类型，提供了许多实用的方法和功能，如整数解析、转换为其他数值类型、字符串转换等。

由于Integer是int的包装类，因此可以使用Integer的对象来调用int的方法和属性。例如：

Integer i = Integer.valueOf(10);  // 装箱，将 int 转换为 Integer 对象
int value = i.intValue();  // 拆箱，将 Integer 对象转换为 int

System.out.println(Integer.MAX_VALUE);  // 输出 Integer 的最大值
System.out.println(Integer.parseInt("10"));  // 解析字符串为 int

//运行结果
2147483647
10

总的来说，int是基本数据类型，而Integer是对int的封装，提供了更多的功能和灵活性。在需要进行基本整数运算和操作的情况下，使用int；而在需要将整数作为对象处理，或者需要利用Integer提供的方法和功能时，使用Integer。

3.2、Integer 类的常用方法

class test {
    public static void main(String[] args) {
        int num = Integer.parseInt("456"); // 将字符串转换为int类型
        Integer iNum = Integer.valueOf("456"); // 通过构造函数创建一个Integer对象
        System.out.println("int数据与Integer对象的比较：" + iNum.equals(num));

        String str2 = Integer.toBinaryString(num); // 获取数字的二进制表示
        String str3 = Integer.toHexString(num); // 获取数字的十六进制表示
        String str4 = Integer.toOctalString(num); // 获取数字的八进制表示
        String str5 = Integer.toString(num, 15); // 获取数字的十五进制表示

        System.out.println("456的二进制表示为：" + str2);
        System.out.println("456的十六进制表示为：" + str3);
        System.out.println("456的八进制表示为：" + str4);
        System.out.println("456的十五进制表示为：" + str5);
    }
}

//运行结果
int数据与Integer对象的比较：true
456的二进制表示为：111001000
456的十六进制表示为：1c8
456的八进制表示为：710
456的十五进制表示为：206

3.3、Integer 类提供了以下 4 个常量:

MAX VALUE：表示 int 类型可取的最大值，即 2^31-1。
MIN_VALUE：表示 int 类型可取的最小值，即-2^31。
SIZE：用来以二进制补码形式表示 int 值的位数
TYPE：表示基本类型 imt 的 Class 实例。

class test {
    public static void main(String[] args) {
        int maxint = Integer.MAX_VALUE; // 获取Integer类的常量值
        int minint = Integer.MIN_VALUE;
        int intsize = Integer.SIZE;

        System.out.println("int类型可取的最大值是：" + maxint); // 将常量值输出
        System.out.println("int类型可取的最小值是：" + minint);
        System.out.println("int类型的二进制位数是：" + intsize);
    }
}

四、Double 类

4.1、double和Double的区别

在Java中，double和Double是两种表示浮点数的数据类型，具有以下区别：

1. 基本数据类型 vs 引用数据类型：

   • double是基本数据类型，用于表示双精度浮点数。它在内存中占据固定的内存空间，不需要进行对象实例化。
   • Double是java.lang.Double类的包装类，用于提供对double基本数据类型的封装。它是引用数据类型，需要进行对象实例化才能使用。

2. 空值（null）处理：

   • double是基本数据类型，不能为null，它的默认值是0.0。
   • Double是引用数据类型，可以为null。

3. 自动装箱和拆箱：

   • 自动装箱：Java提供了自动将double基本类型转换为对应的Double对象的机制，称为装箱（boxing）。
   • 自动拆箱：Java提供了自动将Double对象转换为对应的double基本类型的机制，称为拆箱（unboxing）。

4. 包装类提供的方法和功能：

   • Double类作为引用类型，提供了许多实用的方法和功能，如转换为字符串、比较大小、转换为其他数值类型等。

由于Double是double的包装类，因此可以使用Double的对象来调用double的方法和属性。例如：

Double d = Double.valueOf(3.14);  // 装箱，将 double 转换为 Double 对象
double value = d.doubleValue();  // 拆箱，将 Double 对象转换为 double

System.out.println(Double.MAX_VALUE);  // 输出 Double 的最大值
System.out.println(Double.parseDouble("3.14"));  // 解析字符串为 double

//运行结果
1.7976931348623157E308
3.14

总的来说，double是基本数据类型，而Double是对double的封装，提供了更多的功能和灵活性。在需要对浮点数进行计算和操作的情况下，使用double；而在需要将浮点数作为对象处理，或者需要利用Double提供的方法和功能时，使用Double。

4.2、Double 类的常用方法

class test {
    public static void main(String[] args) {
        Double dNum = Double.valueOf("3.14"); // 通过构造函数创建一个Integer对象
        // 判断是否为非数字值
        System.out.println("3.14是否为非数字值：" + Double.isNaN(dNum.doubleValue()));
        System.out.println("3.14转换为int值为：" + dNum.intValue()); // 转换为int类型
        // 判断大小
        System.out.println("值为3.14的Double对象与3.14的比较结果：" + dNum.equals(3.14));
        // 转换为十六进制
        System.out.println("3.14的十六进制表示为：" + Double.toHexString(dNum));
    }
}

//运行结果
3.14是否为非数字值：false
3.14转换为int值为：3
值为3.14的Double对象与3.14的比较结果：true
3.14的十六进制表示为：0x1.91eb851eb851fp1

4.3、Double 类主要提供了以下常量:

MAX_EXPONENT：返回 int 值，表示有限 double 变量可能具有的最大指数。
MIN_EXPONENT：返回 int 值，表示标准化 double 变量可能具有的最小指数。
NEGATIVE_INFINITY：返回 double 值，表示保存 double 类型的负无穷大值的常量。
POSITIVE_INFINITY：返回 double 值，表示保存 double 类型的正无穷大值的常量。

五、Boolean 类

5.1、boolean 和Boolean 的区别

在Java中，boolean和Boolean是两种表示布尔值的数据类型，具有以下区别：

1. 基本数据类型 vs 引用数据类型：

   • boolean是基本数据类型，只能存储true或false的布尔值，不需要进行对象实例化。
   • Boolean是java.lang.Boolean类的包装类，用于提供对boolean基本数据类型的封装。它是引用数据类型，需要进行对象实例化才能使用。

2. 空值（null）处理：

   • boolean是基本数据类型，不能为null，它的默认值是false。
   • Boolean是引用数据类型，可以为null。

3. 自动装箱和拆箱：

   • 自动装箱：Java提供了自动将boolean基本类型转换为对应的Boolean对象的机制，称为装箱（boxing）。
   • 自动拆箱：Java提供了自动将Boolean对象转换为对应的boolean基本类型的机制，称为拆箱（unboxing）。

4. 包装类提供的方法和功能：

   • Boolean类作为引用类型，提供了许多实用的方法和功能，如转换为字符串、比较大小、逻辑运算等。

由于Boolean是boolean的包装类，因此可以使用Boolean的对象来调用boolean的方法和属性。例如：

class test {
    public static void main(String[] args) {
        Boolean b = Boolean.valueOf(true);   // 装箱，将 boolean 转换为 Boolean 对象
        boolean value = b.booleanValue();    // 拆箱，将 Boolean 对象转换为 boolean

        System.out.println(Boolean.TRUE);    // 输出 Boolean 的常量 TRUE
        System.out.println(Boolean.parseBoolean("true"));   // 解析字符串为 boolean
    }
}

//运行结果
true
true

总的来说，boolean是基本数据类型，而Boolean是对boolean的封装，提供了更多的功能和灵活性。在需要对布尔值进行逻辑运算或条件判断的情况下，使用boolean；而在需要将布尔值作为对象处理，或者需要利用Boolean提供的方法和功能时，使用Boolean。

5.2、Boolean 类的常用方法

class test {
    public static void main(String[] args) {
        //创建 Boolean 对象
        Boolean b1 = Boolean.valueOf("true");
        Boolean b2 = Boolean.valueOf("ok");

        System.out.println("b1:" + b1.booleanValue());
        System.out.println("b2:" + b2.booleanValue());
    }
}

//运行结果
b1:true
b2:false

5.3、Boolean 提供了以下 3 个常量:

TRUE:对应基值 true 的 Boolean 对象
FALSE:对应基值 false 的 Boolean 对象。
TYPE:基本类型 boolean 的 Class 对象

六、Character 类

6.1、char 和Character 的区别

在Java中，char和Character是两种表示字符的数据类型，具有以下区别：

1. 基本数据类型 vs 引用数据类型：

   • char是基本数据类型，用于表示单个字符。它在内存中占据固定的内存空间，不需要进行对象实例化。
   • Character是java.lang.Character类的包装类，用于提供对char基本数据类型的封装。它是引用数据类型，需要进行对象实例化才能使用。

2. 空值（null）处理：

   • char是基本数据类型，不能为null，它没有默认值。
   • Character是引用数据类型，可以为null。

3. 自动装箱和拆箱：

   • 自动装箱：Java提供了自动将char基本类型转换为对应的Character对象的机制，称为装箱（boxing）。
   • 自动拆箱：Java提供了自动将Character对象转换为对应的char基本类型的机制，称为拆箱（unboxing）。

4. 包装类提供的方法和功能：

   • Character类作为引用类型，提供了许多实用的方法和功能，如大小写转换、字符类型判断、字符比较等。

由于Character是char的包装类，因此可以使用Character的对象来调用char的方法和属性。例如：

class test {
    public static void main(String[] args) {
        Character c = Character.valueOf('A');  // 装箱，将 char 转换为 Character 对象
        char value = c.charValue();  // 拆箱，将 Character 对象转换为 char

        System.out.println(Character.isLetter('A'));  // 判断字符是否为字母
        System.out.println(Character.toLowerCase('A'));  // 将字符转换为小写
    }
}

//运行结果
true
a

总的来说，char是基本数据类型，而Character是对char的包装，提供了更多的功能和灵活性。在需要处理单个字符并进行相关运算的情况下，使用char；而在需要将字符作为对象处理，或者需要利用Character提供的方法和功能时，使用Character。

6.2、Character 类的常用方法

class test {
    public static void main(String[] args) {
        Character mychar1 = Character.valueOf('A'); // 声明Character对象
        Character mychar2 = Character.valueOf('a'); // 声明Character对象
        if (Character.isUpperCase(mychar1)) { // 判断是否为大写字母
            System.out.println(mychar1 + "是大写字母 ");
            // 转换为小写
            System.out.println("转换为小写字母的结果： " + Character.toLowerCase(mychar1));
        }
        if (Character.isLowerCase(mychar2)) { // 判断是否为小写字母
            System.out.println(mychar2 + "是小写字母");
            // 转换为大写
            System.out.println("转换为大写字母的结果： " + Character.toUpperCase(mychar2));
        }
    }
}

//运行结果
A是大写字母 
转换为小写字母的结果： a
a是小写字母
转换为大写字母的结果： A

6.3、Character 类提供了大量表示特定字符的常量

例如:
CONNECTOR_PUNCTUATION：返回 byte 型值，表示 Unicode 规范中的常规类别“Pc”
UNASSIGNED：返回 byte 型值，表示 Unicode 规范中的常规类别“Cn”。
TITLECASE_LETTER：返回 bvte 型值，表示 Unicode 规范中的常规类别“Lt”。

七、Number 类

前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类Number 类，该类是一个抽象类，它是 Byte、Integer、Short、Long、Float 和 Double 类的父类，其子类必须提供将表示的数值转换为 byte、int、short、long、float 和 double 的方法。例如，doubleValue0方法返回双精度浮点值，floatValue0方法返回单精度浮点值

在Java中，Number类是一个抽象类，它是所有数字类型的父类。Number类提供了对数字类型进行通用操作和转换的方法。Number类的子类包括Byte、Short、Integer、Long、Float和Double等。

以下是Number类的一些常用方法：

1. doubleValue()：返回以double类型表示的数值。
2. floatValue()：返回以float类型表示的数值。
3. intValue()：返回以int类型表示的数值。
4. longValue()：返回以long类型表示的数值。
5. byteValue()：返回以byte类型表示的数值。
6. shortValue()：返回以short类型表示的数值。

除了上述方法，Number类还提供了比较和转换的方法，例如：

1. equals(Object obj)：比较两个Number对象是否相等。
2. compareTo(Number another)：将一个Number对象与另一个Number对象进行比较。
3. toString()：将Number对象转换为字符串表示。

由于Number类是抽象类，不能直接实例化。但可以通过其子类的对象来调用Number类提供的方法。例如：

class test {
    public static void main(String[] args) {
        Integer i = 10;
        Double d = 3.14;

        int value2 = i.intValue();  // 调用 Number 类的方法
        double value1 = d.doubleValue();  // 调用 Number 类的方法
        
        System.out.println(i.equals(10));  // 调用 Number 类的方法进行比较
        System.out.println(d.toString());  // 调用 Number 类的方法转换为字符串
    }
}

//运行结果
true
3.14

通过继承和多态，Number类提供了通用的数值操作和转换，方便处理不同的数字类型。