Java 中基本数据类型的包装类详解

艾伦~耶格尔

于 2024-09-14 21:33:47 发布

阅读量643

点赞数 20

分类专栏： Java初级文章标签： java 开发语言学习

本文链接：https://blog.csdn.net/weixin_64178283/article/details/142266576

版权

Java初级专栏收录该内容

14 篇文章 0 订阅

订阅专栏

前言：在 Java 中，我们经常会使用基本数据类型，例如 int, double, boolean 等。这些类型直接存储在内存中，并以二进制形式表示。然而，有时我们需要将这些基本数据类型转换为对象，以便能够使用对象的方法和特性。这就是包装类发挥作用的地方。

1.什么是包装类？

包装类是为每个基本数据类型提供对应的类，它们将基本数据类型“包装”成对象。例如，int 的包装类是 Integer，double 的包装类是 Double，boolean 的包装类是 Boolean。

2.为什么要使用包装类？

将基本数据类型转换为对象： 许多 Java 集合类和框架方法需要对象作为参数，而不能直接接受基本数据类型。包装类允许我们将基本数据类型转换为对象，以便能够使用这些方法。
使用对象的方法和特性： 包装类提供了许多有用的方法和特性，例如 parseInt() 用于将字符串转换为整数，valueOf() 用于将基本数据类型转换为包装类对象，以及 toString() 用于将包装类对象转换为字符串。
Null 值： 基本数据类型不能为 null，而包装类可以。这在某些情况下非常有用，例如在方法参数中表示可选值。

3.基本数据类型和包装类的对应关系：

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

代码示例：

public class WrapperClassExample {

    public static void main(String[] args) {

        // 基本数据类型
        int num = 10;
        double price = 19.99;

        // 将基本数据类型转换为包装类对象
        Integer numObj = Integer.valueOf(num);
        Double priceObj = Double.valueOf(price);

        // 使用包装类的方法
        System.out.println("Integer 对象的值：" + numObj.intValue()); // 输出：Integer 对象的值：10
        System.out.println("Double 对象的值：" + priceObj.doubleValue()); // 输出：Double 对象的值：19.99

        // 将包装类对象转换为基本数据类型
        int num2 = numObj.intValue();
        double price2 = priceObj.doubleValue();

        // 使用包装类的静态方法
        String strNum = "123";
        int num3 = Integer.parseInt(strNum); // 将字符串转换为整数
        System.out.println("字符串转换为整数：" + num3); // 输出：字符串转换为整数：123

        // 使用包装类的自动装箱和拆箱
        Integer num4 = num; // 自动装箱：将基本数据类型自动转换为包装类对象
        int num5 = num4; // 自动拆箱：将包装类对象自动转换为基本数据类型
    }
}

解释：

Integer.valueOf(num) 和 Double.valueOf(price) 将基本数据类型转换为包装类对象。
numObj.intValue() 和 priceObj.doubleValue() 将包装类对象转换为基本数据类型。
Integer.parseInt(strNum) 是一个静态方法，用于将字符串转换为整数。
自动装箱和拆箱是指 Java 编译器自动将基本数据类型转换为包装类对象，以及将包装类对象转换为基本数据类型。

4. 八种包装类用法示例

1) Byte

public class ByteExample {
    public static void main(String[] args) {
        // 从基本数据类型创建 Byte 对象
        byte primitiveByte = 10;
        Byte byteObject = Byte.valueOf(primitiveByte);

        // 从字符串创建 Byte 对象
        String byteString = "20";
        Byte byteObjectFromString = Byte.valueOf(byteString);

        // 使用 Byte 对象的方法
        System.out.println("Byte 对象的值：" + byteObject.byteValue()); // 输出：Byte 对象的值：10
        System.out.println("Byte 对象的最大值：" + Byte.MAX_VALUE); // 输出：Byte 对象的最大值：127
        System.out.println("Byte 对象的最小值：" + Byte.MIN_VALUE); // 输出：Byte 对象的最小值：-128

        // 自动装箱和拆箱
        Byte autoBoxedByte = 30; // 自动装箱
        byte autoUnboxedByte = autoBoxedByte; // 自动拆箱
    }
}

2) Short

public class ShortExample {
    public static void main(String[] args) {
        short primitiveShort = 100;
        Short shortObject = Short.valueOf(primitiveShort);

        String shortString = "200";
        Short shortObjectFromString = Short.valueOf(shortString);

        System.out.println("Short 对象的值：" + shortObject.shortValue()); // 输出：Short 对象的值：100
        System.out.println("Short 对象的最大值：" + Short.MAX_VALUE); // 输出：Short 对象的最大值：32767
        System.out.println("Short 对象的最小值：" + Short.MIN_VALUE); // 输出：Short 对象的最小值：-32768

        Short autoBoxedShort = 300;
        short autoUnboxedShort = autoBoxedShort;
    }
}

3) Integer

public class IntegerExample {
    public static void main(String[] args) {
        int primitiveInt = 1000;
        Integer intObject = Integer.valueOf(primitiveInt);

        String intString = "2000";
        Integer intObjectFromString = Integer.valueOf(intString);

        System.out.println("Integer 对象的值：" + intObject.intValue()); // 输出：Integer 对象的值：1000
        System.out.println("Integer 对象的最大值：" + Integer.MAX_VALUE); // 输出：Integer 对象的最大值：2147483647
        System.out.println("Integer 对象的最小值：" + Integer.MIN_VALUE); // 输出：Integer 对象的最小值：-2147483648

        Integer autoBoxedInt = 3000;
        int autoUnboxedInt = autoBoxedInt;
    }
}

4) Long

public class LongExample {
    public static void main(String[] args) {
        long primitiveLong = 10000;
        Long longObject = Long.valueOf(primitiveLong);

        String longString = "20000";
        Long longObjectFromString = Long.valueOf(longString);

        System.out.println("Long 对象的值：" + longObject.longValue()); // 输出：Long 对象的值：10000
        System.out.println("Long 对象的最大值：" + Long.MAX_VALUE); // 输出：Long 对象的最大值：9223372036854775807
        System.out.println("Long 对象的最小值：" + Long.MIN_VALUE); // 输出：Long 对象的最小值：-9223372036854775808

        Long autoBoxedLong = 30000L;
        long autoUnboxedLong = autoBoxedLong;
    }
}

5) Float

public class FloatExample {
    public static void main(String[] args) {
        float primitiveFloat = 10.5f;
        Float floatObject = Float.valueOf(primitiveFloat);

        String floatString = "20.75";
        Float floatObjectFromString = Float.valueOf(floatString);

        System.out.println("Float 对象的值：" + floatObject.floatValue()); // 输出：Float 对象的值：10.5
        System.out.println("Float 对象的最大值：" + Float.MAX_VALUE); // 输出：Float 对象的最大值：3.4028235E38
        System.out.println("Float 对象的最小值：" + Float.MIN_VALUE); // 输出：Float 对象的最小值：1.4E-45

        Float autoBoxedFloat = 30.25f;
        float autoUnboxedFloat = autoBoxedFloat;
    }
}

6) Double

public class DoubleExample {
    public static void main(String[] args) {
        double primitiveDouble = 10.5;
        Double doubleObject = Double.valueOf(primitiveDouble);

        String doubleString = "20.75";
        Double doubleObjectFromString = Double.valueOf(doubleString);

        System.out.println("Double 对象的值：" + doubleObject.doubleValue()); // 输出：Double 对象的值：10.5
        System.out.println("Double 对象的最大值：" + Double.MAX_VALUE); // 输出：Double 对象的最大值：1.7976931348623157E308
        System.out.println("Double 对象的最小值：" + Double.MIN_VALUE); // 输出：Double 对象的最小值：4.9E-324

        Double autoBoxedDouble = 30.25;
        double autoUnboxedDouble = autoBoxedDouble;
    }
}

7) Character

public class CharacterExample {
    public static void main(String[] args) {
        char primitiveChar = 'A';
        Character charObject = Character.valueOf(primitiveChar);

        System.out.println("Character 对象的值：" + charObject.charValue()); // 输出：Character 对象的值：A
        System.out.println("Character 对象是否为数字：" + Character.isDigit(primitiveChar)); // 输出：Character 对象是否为数字：false
        System.out.println("Character 对象是否为字母：" + Character.isLetter(primitiveChar)); // 输出：Character 对象是否为字母：true

        Character autoBoxedChar = 'B';
        char autoUnboxedChar = autoBoxedChar;
    }
}

8) Boolean

public class BooleanExample {
    public static void main(String[] args) {
        boolean primitiveBoolean = true;
        Boolean booleanObject = Boolean.valueOf(primitiveBoolean);

        System.out.println("Boolean 对象的值：" + booleanObject.booleanValue()); // 输出：Boolean 对象的值：true
        System.out.println("Boolean 对象的字符串表示：" + booleanObject.toString()); // 输出：Boolean 对象的字符串表示：true

        Boolean autoBoxedBoolean = false;
        boolean autoUnboxedBoolean = autoBoxedBoolean;
    }
}

5.装箱

1) 自动装箱 (Autoboxing)

自动装箱是指 Java 编译器自动将基本数据类型转换为相应的包装类对象的过程。例如，将 int 类型的变量自动转换为 Integer 类型的对象。

用法示例：

int num = 10;
Integer numObj = num; // 自动装箱：int 类型的变量 num 自动转换为 Integer 类型的对象 numObj

在上面的代码中，numObj 是一个 Integer 类型的对象，它的值是 num 变量的值。

2) 自动拆箱 (Unboxing)

自动拆箱是指 Java 编译器自动将包装类对象转换为相应的基本数据类型的过程。例如，将 Integer 类型的对象自动转换为 int 类型的变量。

用法示例：

Integer numObj = 10;
int num = numObj; // 自动拆箱：Integer 类型的对象 numObj 自动转换为 int 类型的变量 num

在上面的代码中，num 是一个 int 类型的变量，它的值是 numObj 对象的值。

3) 注意：

自动装箱和拆箱发生在编译时，而不是运行时。
自动装箱和拆箱可能会带来一些性能开销，因为它们需要创建新的对象。
在某些情况下，手动进行装箱和拆箱可能会提高代码的可读性和性能。

结语：包装类是 Java 中非常重要的概念，它们允许我们将基本数据类型转换为对象，并使用对象的方法和特性。以及自动装箱和拆箱是 Java 中非常方便的特性，它们简化了基本数据类型和包装类对象之间的转换。了解自动装箱和拆箱的概念和用法对于编写高质量的 Java 代码至关重要。最后，包装类及其使用方法对于编写高质量的 Java 代码至关重要。希望这期知识对于各位看官有所帮助，感谢各位看官观看，下期见，谢谢~