Java幂运算怎么快速实现？

使用 Math.pow()（最常用）

Math.pow(double a, double b) 是Java标准库提供的幂运算方法，直接返回 (a^b) 的结果：

double result1 = Math.pow(2, 3);   // 8.0 (2³)
double result2 = Math.pow(4, 0.5); // 2.0 (平方根)
double result3 = Math.pow(2.5, 3); // 15.625

特点：

• 支持小数指数（如开方、立方根）
• 返回double类型（可能存在精度问题）
• 指数为负数时计算倒数：Math.pow(2, -2) = 0.25

循环/递归实现（整数指数）

当指数为整数时，可通过循环或递归高效计算：

// 循环实现
public static int power(int base, int exponent) {
    int result = 1;
    for (int i = 0; i < exponent; i++) {
        result *= base;
    }
    return result;
}
// 递归实现（更快）
public static int powerRecursive(int base, int exponent) {
    if (exponent == 0) return 1;
    int half = powerRecursive(base, exponent / 2);
    return (exponent % 2 == 0) ? half * half : half * half * base;
}

适用场景：

• 指数为正整数
• 无浮点数精度问题
• 递归法时间复杂度 (O(log n))（推荐）

使用 BigInteger/BigDecimal（大数运算）

当数值超出long或double范围时：

// 大整数幂运算
BigInteger bigResult = new BigInteger("10").pow(100); // 10¹⁰⁰
// 大小数幂运算（需自定义方法）
BigDecimal bigDec = new BigDecimal("2.5");
BigDecimal bigPower = bigDec.pow(3); // 15.625（仅支持整数指数）

优势：

• 处理天文数字（如加密算法）
• 避免溢出问题
• BigDecimal.pow()只支持整数指数

位移运算（2的整数幂）

对 (2^n) 的幂运算，使用位左移效率最高：

int twoPower3 = 1 << 3;   // 8 (2³)
int twoPower10 = 1 << 10; // 1024 (2¹⁰)

原理：
1 << n 等价于 (2^n)，仅适用于2的整数次幂。

性能与精度对比

常见问题及注意事项

1. 负数指数处理
   Math.pow(2, -3) = 0.125，自定义方法需额外逻辑：

   public static double powerNegative(int base, int exponent) {
       return 1.0 / power(base, -exponent); // 先转为正指数再取倒数
   }

2. 浮点数精度问题
   Math.pow(0.1, 2) 可能返回 010000000000000002，需用BigDecimal或四舍五入：

   double fixed = Math.round(Math.pow(0.1, 2) * 100.0) / 100.0; // 0.01

3. 指数为0的特殊情况
   所有实现需兼容 (a^0 = 1)（包括 (0^0 = 1)，数学有争议但Java返回1）。

4. 整数溢出
   循环计算大整数幂时，用long或BigInteger避免溢出：

   // 错误示例：10¹⁰超过int上限
   int overflow = power(10, 10); // 返回错误值

最佳实践选择

• 日常小数/整数幂 → Math.pow()
• 2的整数幂 → 位运算（1 << n）
• 大整数幂运算 → BigInteger.pow()
• 高精度小数幂 → BigDecimal + 自定义方法
• 正整数幂（非大数） → 递归法（效率最高）

引用说明： 参考Oracle官方文档 Math类、BigInteger类 及IEEE 754浮点数标准，代码示例经过JDK 8~21环境验证。