哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

Java零基础入门–自动拆箱

前言

在之前的文章中，我们介绍了Java中的自动装箱（autoboxing）特性。我们学习了如何将基本数据类型转换为对应的包装类对象，这使得基本数据类型与对象之间的转换变得简便。今天，我们将继续探讨与自动装箱密切相关的一个重要概念——自动拆箱（unboxing）。自动拆箱使得将包装类对象自动转换为基本数据类型变得轻而易举，这对于编写高效和简洁的Java代码至关重要。

摘要

本文将深入探讨Java中的自动拆箱机制。我们将从以下几个方面对自动拆箱进行详细介绍：

• 自动拆箱的定义和工作机制。
• 自动拆箱在实际开发中的应用。
• 通过示例代码展示自动拆箱的实际效果。
• 自动拆箱的优缺点分析。
• 自动拆箱在不同场景下的应用示例。
• 测试用例的设计与分析。

简介

自动拆箱是Java编程语言的一项重要特性，它允许将包装类对象自动转换回基本数据类型。这一特性在Java的装箱机制中扮演了重要角色，使得程序员在处理基本数据类型和包装类之间的转换时无需手动干预。自动拆箱与自动装箱相对，通过自动拆箱，我们可以轻松地将 Integer、Double 等包装类对象转换为 int、double 等基本数据类型。

概述

在Java中，自动拆箱由编译器自动处理。编译器在编译时会根据需要自动将包装类对象转换为基本数据类型。当我们将包装类对象赋值给基本数据类型变量时，编译器会自动完成这一转换过程。自动拆箱使得在对象和基本数据类型之间的转换变得无缝，简化了代码编写。

核心源码解读

以下是一个简单的自动拆箱示例：

public class UnboxingTest {
    public static void main(String[] args) {
        // 自动装箱
        Integer boxedInteger = 42;
        Double boxedDouble = 3.14;

        // 自动拆箱
        int unboxedInteger = boxedInteger; // 自动拆箱
        double unboxedDouble = boxedDouble; // 自动拆箱

        // 输出结果
        System.out.println("Boxed Integer: " + boxedInteger);
        System.out.println("Unboxed Integer: " + unboxedInteger);
        System.out.println("Boxed Double: " + boxedDouble);
        System.out.println("Unboxed Double: " + unboxedDouble);
    }
}

代码解读

1. 自动装箱：

   • 在代码开始处，我们将基本数据类型的值 42 和 3.14 自动装箱为 Integer 和 Double 对象。这意味着 boxedInteger 和 boxedDouble 分别持有 42 和 3.14 的对象表示。

2. 自动拆箱：

   • 在赋值语句 int unboxedInteger = boxedInteger; 和 double unboxedDouble = boxedDouble; 中，boxedInteger 和 boxedDouble 自动拆箱为基本数据类型 int 和 double。

3. 输出结果：

   • 最后，我们通过 System.out.println 打印包装类对象及其对应的基本数据类型值，以验证自动拆箱的结果。

案例分析

案例 1：处理用户输入

假设我们从用户输入中获取数据，并将其存储为包装类对象。在进行计算时，我们需要将这些包装类对象转换为基本数据类型。自动拆箱使得这一过程变得简单直观。例如：

import java.util.Scanner;

public class UserInputTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter an integer: ");
        Integer userInputInteger = scanner.nextInt(); // 用户输入的整数

        System.out.print("Enter a double: ");
        Double userInputDouble = scanner.nextDouble(); // 用户输入的浮点数

        // 自动拆箱
        int inputInt = userInputInteger;
        double inputDouble = userInputDouble;

        // 输出结果
        System.out.println("Entered Integer: " + inputInt);
        System.out.println("Entered Double: " + inputDouble);

        scanner.close();
    }
}

案例 2：计算平均值

在计算平均值时，我们通常会使用包装类来处理数据。自动拆箱使得将包装类对象转换为基本数据类型，进而进行计算变得非常方便。

public class AverageCalculator {
    public static void main(String[] args) {
        Integer num1 = 10;
        Integer num2 = 20;
        Integer num3 = 30;

        // 自动拆箱
        int sum = num1 + num2 + num3;
        double average = sum / 3.0;

        // 输出结果
        System.out.println("Sum: " + sum);
        System.out.println("Average: " + average);
    }
}

优缺点分析

优点

1. 简化代码：

   • 自动拆箱使得基本数据类型和包装类对象之间的转换变得透明，减少了显式的类型转换代码，使得代码更简洁。

2. 提高可读性：

   • 自动拆箱减少了代码中的冗余部分，使得代码更加易于理解和维护。

缺点

1. 隐性转换：

   • 自动拆箱是隐式完成的，有时可能会导致错误难以察觉。例如，当包装类对象为 null 时，自动拆箱会抛出 NullPointerException，这可能会导致程序崩溃。

2. 性能开销：

   • 尽管自动拆箱简化了代码，但频繁进行装箱和拆箱操作可能会带来性能开销，特别是在高性能要求的场景中。

类代码方法介绍及演示

Integer 类的方法

• intValue()：返回 Integer 对象的 int 值。
• parseInt(String s)：将字符串解析为 int 值。

Double 类的方法

• doubleValue()：返回 Double 对象的 double 值。
• parseDouble(String s)：将字符串解析为 double 值。

以下是一个演示这些方法的示例代码：

public class WrapperMethodsTest {
    public static void main(String[] args) {
        Integer boxedInteger = 123;
        Double boxedDouble = 45.67;

        // 使用 Integer 类的方法
        int intValue = boxedInteger.intValue();
        System.out.println("Integer value from intValue(): " + intValue);

        // 使用 Double 类的方法
        double doubleValue = boxedDouble.doubleValue();
        System.out.println("Double value from doubleValue(): " + doubleValue);

        // 使用 parseXXX 方法
        int parsedInt = Integer.parseInt("789");
        double parsedDouble = Double.parseDouble("89.01");

        System.out.println("Parsed Integer: " + parsedInt);
        System.out.println("Parsed Double: " + parsedDouble);
    }
}

测试用例

测试用例 1：自动拆箱验证

public class UnboxingTest {
    public static void main(String[] args) {
        Integer boxedInteger = 100;
        Double boxedDouble = 50.5;

        // 自动拆箱
        int unboxedInteger = boxedInteger;
        double unboxedDouble = boxedDouble;

        // 验证拆箱结果
        System.out.println("Unboxed Integer: " + unboxedInteger); // 100
        System.out.println("Unboxed Double: " + unboxedDouble); // 50.5
    }
}

测试用例 2：包装类方法验证

public class WrapperMethodsTest {
    public static void main(String[] args) {
        Integer boxedInteger = 456;
        Double boxedDouble = 78.9;

        // 使用包装类方法
        int intValue = boxedInteger.intValue();
        double doubleValue = boxedDouble.doubleValue();

        // 验证结果
        System.out.println("Integer value from intValue(): " + intValue); // 456
        System.out.println("Double value from doubleValue(): " + doubleValue); // 78.9
    }
}

测试结果预期

测试用例 1 结果

Unboxed Integer: 100
Unboxed Double: 50.5

测试用例 2 结果

Integer value from intValue(): 456
Double value from doubleValue(): 78.9

测试代码分析

测试用例1代码解析

针对如上示例代码，这里我给大家详细的代码剖析下，以便于帮助大家理解的更为透彻，帮助大家早日掌握。

下面是对 UnboxingTest 类的详细解析。这段代码展示了自动拆箱的基本用法，演示了如何将包装类对象自动转换为基本数据类型。

public class UnboxingTest {
    public static void main(String[] args) {
        Integer boxedInteger = 100;
        Double boxedDouble = 50.5;

        // 自动拆箱
        int unboxedInteger = boxedInteger;
        double unboxedDouble = boxedDouble;

        // 验证拆箱结果
        System.out.println("Unboxed Integer: " + unboxedInteger); // 100
        System.out.println("Unboxed Double: " + unboxedDouble); // 50.5
    }
}

代码解析

1. 定义包装类对象：

   Integer boxedInteger = 100;
   Double boxedDouble = 50.5;
   

   • boxedInteger 是一个 Integer 类型的对象，表示整数 100。
   • boxedDouble 是一个 Double 类型的对象，表示浮点数 50.5。
   • 这些对象通过自动装箱机制创建，其中 100 和 50.5 是基本数据类型 int 和 double 的值，Java 自动将它们封装成 Integer 和 Double 对象。

2. 自动拆箱：

   int unboxedInteger = boxedInteger;
   double unboxedDouble = boxedDouble;
   

   • int unboxedInteger = boxedInteger;：这里的 boxedInteger 被自动拆箱成 int 类型的值 100。这是 Java 自动拆箱的示例，Java 编译器自动将 Integer 对象转换为 int 基本数据类型。
   • double unboxedDouble = boxedDouble;：这里的 boxedDouble 被自动拆箱成 double 类型的值 50.5。类似地，Java 自动将 Double 对象转换为 double 基本数据类型。

3. 输出结果：

   System.out.println("Unboxed Integer: " + unboxedInteger); // 100
   System.out.println("Unboxed Double: " + unboxedDouble); // 50.5
   

   • System.out.println("Unboxed Integer: " + unboxedInteger);：打印 unboxedInteger 的值，应输出 100。
   • System.out.println("Unboxed Double: " + unboxedDouble);：打印 unboxedDouble 的值，应输出 50.5。

自动拆箱的过程

• 定义包装类对象：Java 自动创建了 Integer 和 Double 对象。
• 自动拆箱：在赋值操作中，Java 自动将包装类对象转换为基本数据类型。这种转换是由 Java 编译器在运行时自动处理的，因此程序员无需显式地调用拆箱方法。
• 验证结果：打印拆箱后的结果，确认转换是否正确。

测试用例2代码解析

针对如上示例代码，这里我给大家详细的代码剖析下，以便于帮助大家理解的更为透彻，帮助大家早日掌握。

以下是对 WrapperMethodsTest 类的详细解析。这段代码演示了如何使用 Integer 和 Double 类的包装类方法将包装类对象转换为基本数据类型。

public class WrapperMethodsTest {
    public static void main(String[] args) {
        Integer boxedInteger = 456;
        Double boxedDouble = 78.9;

        // 使用包装类方法
        int intValue = boxedInteger.intValue();
        double doubleValue = boxedDouble.doubleValue();

        // 验证结果
        System.out.println("Integer value from intValue(): " + intValue); // 456
        System.out.println("Double value from doubleValue(): " + doubleValue); // 78.9
    }
}

代码解析

1. 定义包装类对象：

   Integer boxedInteger = 456;
   Double boxedDouble = 78.9;
   

   • boxedInteger 是一个 Integer 类型的对象，表示整数 456。
   • boxedDouble 是一个 Double 类型的对象，表示浮点数 78.9。
   • 这些对象是通过自动装箱机制创建的。Java 自动将基本数据类型 int 和 double 转换为相应的包装类对象。

2. 使用包装类方法：

   int intValue = boxedInteger.intValue();
   double doubleValue = boxedDouble.doubleValue();
   

   • boxedInteger.intValue()：调用 Integer 类的 intValue() 方法，将 boxedInteger 对象中的 Integer 值转换为基本数据类型 int。返回值 intValue 为 456。
   • boxedDouble.doubleValue()：调用 Double 类的 doubleValue() 方法，将 boxedDouble 对象中的 Double 值转换为基本数据类型 double。返回值 doubleValue 为 78.9。

3. 输出结果：

   System.out.println("Integer value from intValue(): " + intValue); // 456
   System.out.println("Double value from doubleValue(): " + doubleValue); // 78.9
   

   • System.out.println("Integer value from intValue(): " + intValue);：打印 intValue 的值，应该输出 456。
   • System.out.println("Double value from doubleValue(): " + doubleValue);：打印 doubleValue 的值，应该输出 78.9。

小结

本文详细介绍了Java中的自动拆箱（unboxing）机制，包括其定义、应用、优缺点和代码示

例。通过具体的示例和测试用例，我们验证了自动拆箱的工作机制，并探讨了其在实际开发中的应用场景。

总结

自动拆箱是Java编程语言中的一个重要特性，使得在对象和基本数据类型之间的转换变得更为简便。理解和掌握自动拆箱机制，有助于编写更高效、简洁的Java代码。希望本文的介绍能够帮助你更好地理解自动拆箱，并在实际编程中加以运用。

寄语

编程是探索和实践的过程，希望你在Java编程的旅程中不断前进，深入理解每一个编程概念，提升你的编程技能。愿你在编程道路上收获满满，写出更加优雅和高效的代码！

… …

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

---

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。

⭐️若有疑问，就请评论留言告诉我叭。