“Java double转double” 通常有两种理解场景：

1. 基础类型 double 赋值给另一个基础类型 double：这是最常见、最直接的情况,本质上是值的传递。
2. Double 对象（包装类）转换为 double 基础类型：这是拆箱操作，在处理泛型、集合或需要对象引用时非常普遍。

下面我将详细解释这两种情况,并提供相关的代码示例和注意事项。

基础类型 double 赋值给另一个 double

这是最简单的情况，你不需要做任何特殊的转换，Java 会自动处理这种类型转换。

核心概念： Java 中 double 是一个基础数据类型，它直接存储数值，不是对象，当你把一个 double 变量的值赋给另一个 double 变量时,只是将内存中的数值拷贝了一份。

代码示例：

public class PrimitiveDoubleExample {
    public static void main(String[] args) {
        // 1. 定义一个 double 变量并初始化
        double sourceValue = 123.456;
        // 2. 将 sourceValue 的值直接赋给另一个 double 变量
        // 这就是所谓的 "double转double"
        double targetValue = sourceValue;
        // 3. 验证结果
        System.out.println("源变量 sourceValue: " + sourceValue);
        System.out.println("目标变量 targetValue: " + targetValue);
        // 修改目标变量，不会影响源变量
        targetValue = 789.012;
        System.out.println("修改后的 targetValue: " + targetValue);
        System.out.println("修改后的 sourceValue (不变): " + sourceValue);
    }
}

输出：

源变量 sourceValue: 123.456
目标变量 targetValue: 123.456
修改后的 targetValue: 789.012
修改后的 sourceValue (不变): 123.456

对于基础类型，直接赋值即可，这是一种高效、直接的值拷贝。

Double 对象转换为 double 基础类型

这是更常见且需要关注的场景。Double 是 double 的包装类，是一个对象，将 Double 对象转换为 double 基础类型的过程称为拆箱。

核心概念：

• Double (对象): 存储在堆内存中，可以包含 null 值，可以作为泛型类型（如 List<Double>）。
• double (基础类型): 存储在栈内存中，有默认值 0，不能为 null,性能更高。

转换方法：

方法 1：自动拆箱 (推荐)

现代 Java (5及以上版本) 支持自动拆箱，当你将一个 Double 对象赋值给一个 double 变量时，Java 编译器会自动调用 doubleValue() 方法。

public class AutoUnboxingExample {
    public static void main(String[] args) {
        // 创建一个 Double 对象
        Double doubleObject = 987.654;
        // 自动拆箱：将 Double 对象转换为 double 基础类型
        double primitiveDouble = doubleObject;
        System.out.println("Double 对象: " + doubleObject);
        System.out.println("double 基础类型: " + primitiveDouble);
    }
}

方法 2：手动调用 doubleValue() 方法

这是显式进行拆箱的方式，效果与自动拆箱完全相同，但代码更清晰,明确表达了你的意图。

public class ManualUnboxingExample {
    public static void main(String[] args) {
        // 创建一个 Double 对象
        Double doubleObject = 555.555;
        // 手动调用 doubleValue() 方法进行转换
        double primitiveDouble = doubleObject.doubleValue();
        System.out.println("Double 对象: " + doubleObject);
        System.out.println("double 基础类型: " + primitiveDouble);
    }
}

⚠️ 重要注意事项：NullPointerException

当 Double 对象为 null 时，尝试将其拆箱为 double 会抛出 NullPointerException,这是处理包装类时最常见的错误。

错误示例：

public class NullPointerExample {
    public static void main(String[] args) {
        Double nullDoubleObject = null;
        // 这行代码会抛出 NullPointerException
        // 因为 null 对象没有方法可以调用
        double primitiveDouble = nullDoubleObject; // 自动拆箱失败
        // 或者
        // double primitiveDouble = nullDoubleObject.doubleValue(); // 手动拆箱也失败
    }
}

如何安全地转换？

在不确定 Double 对象是否为 null 时,一定要进行判断。

public class SafeConversionExample {
    public static void main(String[] args) {
        Double nullDoubleObject = null;
        double result = 0.0; // 定义一个默认值
        // 安全地转换
        if (nullDoubleObject != null) {
            result = nullDoubleObject; // 或 nullDoubleObject.doubleValue()
        }
        System.out.println("转换结果: " + result); // 输出: 转换结果: 0.0
    }
}

相关操作：double 转 Double (装箱)

与拆箱相反，将 double 基础类型转换为 Double 对象的过程称为装箱。

自动装箱

double primitiveDouble = 3.14159;
Double doubleObject = primitiveDouble; // 自动装箱

手动装箱

double primitiveDouble = 2.71828;
Double doubleObject = Double.valueOf(primitiveDouble);

总结与对比

希望这个详细的解释能帮助你彻底理解 Java 中 double 和 Double 之间的转换关系！