核心方法

最推荐使用 Java 提供的内置方法，因为它简洁、高效且能处理各种边界情况（如负数、前缀等）。

使用 Integer.parseInt() (最常用)

这是将字符串转换为整数的标准方法,它有一个重载版本，可以指定字符串的基数（Radix），对于 16 进制，基数就是 16。

语法:

int decimalValue = Integer.parseInt(hexString, 16);

示例代码:

public class HexToDecimal {
    public static void main(String[] args) {
        // 示例 1: 标准的16进制字符串
        String hex1 = "1A3F";
        int decimal1 = Integer.parseInt(hex1, 16);
        System.out.println("16进制 '" + hex1 + "' 转换为10进制是: " + decimal1); // 输出: 6719
        // 示例 2: 包含小写字母
        String hex2 = "ff";
        int decimal2 = Integer.parseInt(hex2, 16);
        System.out.println("16进制 '" + hex2 + "' 转换为10进制是: " + decimal2); // 输出: 255
        // 示例 3: 带有 '0x' 前缀的字符串
        // Integer.parseInt() 会忽略 '0x' 前缀，非常方便
        String hex3 = "0x1a3f";
        int decimal3 = Integer.parseInt(hex3, 16);
        System.out.println("16进制 '" + hex3 + "' 转换为10进制是: " + decimal3); // 输出: 6719
        // 示例 4: 负数的16进制表示 (补码形式)
        String hex4 = "-FF"; // -255 的16进制表示
        int decimal4 = Integer.parseInt(hex4, 16);
        System.out.println("16进制 '" + hex4 + "' 转换为10进制是: " + decimal4); // 输出: -255
    }
}

异常处理

在实际应用中,输入的字符串可能不是一个有效的 16 进制字符串（包含非法字符 'G'），这时 Integer.parseInt() 会抛出 NumberFormatException，使用 try-catch 块进行异常处理是非常重要的。

示例代码 (带异常处理):

public class HexToDecimalSafe {
    public static void main(String[] args) {
        String[] testCases = {"1A3F", "ff", "0x1a3f", "-FF", "ZZZ", ""};
        for (String hex : testCases) {
            try {
                int decimal = Integer.parseInt(hex, 16);
                System.out.printf("16进制 '%s' -> 10进制: %d%n", hex, decimal);
            } catch (NumberFormatException e) {
                System.out.printf("错误: 字符串 '%s' 不是有效的16进制表示。%n", hex);
            }
        }
    }
}

输出:

16进制 '1A3F' -> 10进制: 6719
16进制 'ff' -> 10进制: 255
16进制 '0x1a3f' -> 10进制: 6719
16进制 '-FF' -> 10进制: -255
错误: 字符串 'ZZZ' 不是有效的16进制表示。
错误: 字符串 '' 不是有效的16进制表示。

进阶用法：处理不同数据类型

Integer.parseInt() 返回的是 int 类型，如果你的 16 进制字符串可能表示一个超出 int 范围的数（一个 64 位的 long 类型），你应该使用对应的 Long 类方法。

使用 Long.parseLong()

语法:

long decimalValue = Long.parseLong(hexString, 16);

示例代码:

public class HexToLong {
    public static void main(String[] args) {
        // 一个超过 int 最大值 (2,147,483,647) 的16进制数
        String largeHex = "FFFFFFFF"; // 这是 -1 的 int 补码，但作为无符号数很大
        long decimalLong = Long.parseLong(largeHex, 16);
        System.out.println("16进制 '" + largeHex + "' 转换为10进制 (long) 是: " + decimalLong); // 输出: 4294967295
        // 一个更大的16进制数
        String veryLargeHex = "7FFFFFFFFFFFFFFF"; // Long.MAX_VALUE
        long decimalVeryLong = Long.parseLong(veryLargeHex, 16);
        System.out.println("16进制 '" + veryLargeHex + "' 转换为10进制 (long) 是: " + decimalVeryLong); // 输出: 9223372036854775807
    }
}

不推荐的方法（了解即可）

虽然不推荐,但了解这些方法有助于理解底层原理。

手动转换（逐位计算）

这种方法通过遍历字符串的每一个字符,根据其权重（16的幂）来计算最终的十进制值，这有助于理解进制转换的数学原理。

思路:

1. 从字符串的最后一个字符开始向前遍历。
2. 对于每个字符,获取其对应的十进制值（'A' -> 10, 'F' -> 15）。
3. 将该值乘以 16 的相应次方（最后一个字符是 16^0，倒数第二个是 16^1，以此类推）。
4. 将所有结果相加。

示例代码:

public class HexToDecimalManual {
    public static void main(String[] args) {
        String hex = "1A3F";
        int decimal = 0;
        int length = hex.length();
        for (int i = 0; i < length; i++) {
            char c = hex.charAt(length - 1 - i); // 从后往前取字符
            int digitValue;
            // 将字符转换为对应的数值
            if (c >= '0' && c <= '9') {
                digitValue = c - '0';
            } else if (c >= 'A' && c <= 'F') {
                digitValue = 10 + (c - 'A');
            } else if (c >= 'a' && c <= 'f') {
                digitValue = 10 + (c - 'a');
            } else {
                throw new IllegalArgumentException("无效的16进制字符: " + c);
            }
            // 累加到最终结果
            decimal += digitValue * Math.pow(16, i);
        }
        System.out.println("手动转换: 16进制 '" + hex + "' -> 10进制: " + decimal); // 输出: 6719
    }
}

为什么不推荐？

• 代码冗长：相比一行代码的 Integer.parseInt()，手动方法要复杂得多。
• 性能较低：循环和 Math.pow() 的计算效率不如 Java 底层优化的 parseInt 方法。
• 容易出错：需要自己处理大小写、非法字符等各种边界情况。

最佳实践： 在绝大多数情况下，直接使用 Integer.parseInt() 或 Long.parseLong()，并用 try-catch 包裹起来以处理潜在的格式错误，这是最专业、最高效的做法。