类型转换

这是最常见的情况，指的是将一个 double 类型的值赋给另一个 double 类型的变量，在这种情况下，什么也不需要做,因为类型没有改变。

public class DoubleExample {
    public static void main(String[] args) {
        // 原始的 double 值
        double originalValue = 123.456;
        // "转" 换：将一个 double 赋值给另一个 double 变量
        // 这是最简单、最直接的 "double 转 double"
        double convertedValue = originalValue;
        System.out.println("原始值: " + originalValue); // 输出: 123.456
        System.out.println("转换后值: " + convertedValue); // 输出: 123.456
    }
}

在这个例子里，originalValue 和 convertedValue 都是 double 类型，赋值操作是直接发生的,没有类型转换的开销或精度损失。

更常见的实际需求：从其他类型转换为 double

当人们问“如何转 double”时，真正的意思是如何将其他数据类型（如 int, String, float 等）转换为 double 类型,这才是编程中更频繁遇到的操作。

a) 从 int 或 long 转换为 double

这是隐式类型转换（自动转换），因为 double 的精度范围远大于 int 或 long，Java 编译器会自动将整型提升为 double 类型,无需任何显式操作。

public class IntToDouble {
    public static void main(String[] args) {
        int intValue = 100;
        long longValue = 100000L;
        // 隐式转换，编译器自动完成
        double fromInt = intValue;
        double fromLong = longValue;
        System.out.println("从 int 转换: " + fromInt);      // 输出: 100.0
        System.out.println("从 long 转换: " + fromLong);    // 输出: 100000.0
    }
}

b) 从 float 转换为 double

这也是隐式类型转换。double 是 64 位，float 是 32 位。double 提供了比 float 更高的精度和更大的表示范围，float 可以无损地提升为 double。

public class FloatToDouble {
    public static void main(String[] args) {
        float floatValue = 123.45f; // 注意 f 后缀
        // 隐式转换
        double fromFloat = floatValue;
        System.out.println("原始 float 值: " + floatValue); // 输出: 123.45
        System.out.println("转换后 double 值: " + fromFloat); // 输出: 123.45
    }
}

c) 从 String 转换为 double

这是非常常见的需求，比如从用户输入或文件读取的数字字符串转换为数值，Java 提供了两种主要方式：

使用 Double.parseDouble(String s) (推荐)

这是最标准、最常用的方法，它会尝试将字符串解析为 double，如果字符串不是一个有效的 double 格式，它会抛出 NumberFormatException 异常。

public class StringToDouble {
    public static void main(String[] args) {
        String strNumber = "3.14159";
        String invalidStr = "hello";
        try {
            // 使用 Double.parseDouble 进行转换
            double number = Double.parseDouble(strNumber);
            System.out.println("转换成功: " + number); // 输出: 3.14159
            // 尝试转换无效字符串
            double invalidNumber = Double.parseDouble(invalidStr);
        } catch (NumberFormatException e) {
            System.out.println("转换失败: 字符串 '" + invalidStr + "' 不是有效的数字格式。");
        }
    }
}

使用 Double.valueOf(String s)

这个方法也返回一个 Double 对象（double 的包装类），由于 Java 5+ 的自动拆箱机制，这个 Double 对象会自动转换为基本类型 double，效果和 parseDouble 一样,但返回的是对象。

public class StringToDoubleWithWrapper {
    public static void main(String[] args) {
        String strNumber = "99.99";
        // Double.valueOf 返回一个 Double 对象
        Double doubleObject = Double.valueOf(strNumber);
        // 自动拆箱：Double 对象 -> double 基本类型
        double number = doubleObject;
        System.out.println("转换成功: " + number); // 输出: 99.99
    }
}

Double.parseDouble() 更直接，因为它直接返回 double 基本类型,是处理字符串转数值的首选。

需要注意的陷阱：精度问题

在涉及浮点数转换时，必须注意精度和舍入误差，这是由 float 和 double 基于 IEEE 754 标准的二进制浮点数表示法决定的。

示例：float 转 double 的精度问题

虽然 float 可以无损地存入 double，但在某些极端情况下，如果原始 float 值已经损失了精度，这个损失也会被带入 double。

public class PrecisionIssue {
    public static void main(String[] args) {
        // 一个无法用二进制精确表示的 float 值
        float f = 0.1f;
        // 将它存入 double，精度问题依然存在
        double d = f;
        System.out.println("原始 float 值: " + f);       // 输出: 0.1
        System.out.println("转换后 double 值: " + d);   // 输出: 0.10000000149011612
        // 更明显的问题
        float bigFloat = 123456789.0f;
        double fromBigFloat = bigFloat;
        System.out.println("原始 float: " + bigFloat);      // 输出: 1.23456792E8
        System.out.println("转换后 double: " + fromBigFloat); // 输出: 1.23456792E8
    }
}

double 提供了比 float 更高的精度，但它并不能“修复”一个本身就不精确的 float 值，对于需要高精度的金融计算，应使用 java.math.BigDecimal。

总结表格

希望这个详细的解释能帮助你全面理解在 Java 中如何处理 double 相关的转换！