在 Java 中，表示 10 的 n 次方有几种常见的方法，适用于不同的场景，下面我将为你详细介绍这些方法，并给出代码示例。

使用 Math.pow() (最通用、最推荐)

这是最直接、最符合数学直觉的方法，适用于任何底数和指数的幂运算。

语法: double result = Math.pow(10, n);

• 10 是底数。
• n 是指数。
• 返回值类型是 double，因为结果可能不是整数（10 的 -1 次方是 0.1）。

示例代码:

public class PowerOfTen {
    public static void main(String[] args) {
        int n1 = 3;
        double result1 = Math.pow(10, n1);
        System.out.println("10 的 " + n1 + " 次方是: " + result1); // 输出: 1000.0
        int n2 = 2;
        double result2 = Math.pow(10, n2);
        System.out.println("10 的 " + n2 + " 次方是: " + result2); // 输出: 100.0
        int n3 = -1;
        double result3 = Math.pow(10, n3);
        System.out.println("10 的 " + n3 + " 次方是: " + result3); // 输出: 0.1
        // 处理大指数，结果可能超出 double 的表示范围，返回 Infinity
        int n4 = 309;
        double result4 = Math.pow(10, n4);
        System.out.println("10 的 " + n4 + " 次方是: " + result4); // 输出: Infinity
    }
}

优点:

• 通用性强,可以计算任意底数的幂。
• 代码清晰易读。

缺点:

• 返回类型是 double，如果需要精确的整数结果，需要进行类型转换（long 或 int），但要注意大数溢出的风险。
• 对于整数幂运算,可能存在微小的浮点精度误差（Math.pow(10, 2) 可能是 999999...）。

使用 Math.pow() 并转换为 long (适用于大整数)

当你需要计算 10 的 n 次方并得到一个精确的整数时，特别是当 n 可能很大时，使用 long 类型是更好的选择。

语法: long result = (long) Math.pow(10, n);

示例代码:

public class PowerOfTenLong {
    public static void main(String[] args) {
        int n = 10;
        // Math.pow 返回 double，我们将其强制转换为 long
        long result = (long) Math.pow(10, n);
        System.out.println("10 的 " + n + " 次方 (long) 是: " + result); // 输出: 10000000000
        // 注意：当 n 很大时，10^n 可能会超出 long 的最大值 (2^63 - 1)
        // Math.pow 会返回 Infinity，强制转换后会是 Long.MAX_VALUE，这是不正确的
        int bigN = 20;
        long bigResult = (long) Math.pow(10, bigN);
        System.out.println("10 的 " + bigN + " 次方 (long) 是: " + bigResult); // 输出: 100000000000000000000，但long会溢出
    }
}

注意:

• long 类型的最大值是 9,223,372,036,854,775,807 (约 10 的 18 次方)，当 n > 18 时，10 的 n 次方会超出 long 的范围，导致溢出。Math.pow(10, n) 会返回 Infinity，强制转换为 long 后得到一个错误的值。

使用 1 后面加 n 个 0 (适用于 int 和 long 字面量)

如果你的 n 是一个已知的、较小的常数，并且你需要在代码中直接写出一个常量，这是最简单的方法。

语法:

• int result = 1_0000_0000; // 10^8
• long result = 10_0000_0000L; // 10^9 (注意 L 后缀)

示例代码:

public class PowerOfTenLiteral {
    public static void main(String[] args) {
        // 直接使用字面量
        int tenToThe4 = 10000; // 10^4
        System.out.println("10 的 4 次方 (int 字面量) 是: " + tenToThe4);
        long tenToThe9 = 1000000000L; // 10^9, L 后缀表示 long 类型
        System.out.println("10 的 9 次方 (long 字面量) 是: " + tenToThe9);
        // 使用下划线提高可读性 (Java 7+)
        long tenToThe12 = 1_000_000_000_000L;
        System.out.println("10 的 12 次方 (long 字面量, 带下划线) 是: " + tenToThe12);
    }
}

优点:

• 非常直观,性能最好（编译时就已经确定）。
• 没有精度问题。

缺点:

• 不适用于变量，你不能写成 int n = 5; int result = 1 + "00000";，这是错误的，此方法只适用于已知的、固定的常量。

使用循环 (适用于 BigInteger 或大数计算)

当 n 非常大，导致结果超出了 long 的范围时，你必须使用 java.math.BigInteger 类。BigInteger 可以表示任意大小的整数。

语法:

import java.math.BigInteger;
BigInteger result = BigInteger.TEN.pow(n);

BigInteger.TEN 是 BigInteger 类中预定义的 10。

示例代码:

import java.math.BigInteger;
public class PowerOfTenBigInteger {
    public static void main(String[] args) {
        int n = 100; // 一个非常大的指数
        // 使用 BigInteger
        BigInteger result = BigInteger.TEN.pow(n);
        System.out.println("10 的 " + n + " 次方 (BigInteger) 是:");
        System.out.println(result); // 输出一个 1 后面跟着 100 个 0 的巨大数字
        // 这个方法可以处理任意大的 n，只要内存允许
        int hugeN = 50000;
        BigInteger hugeResult = BigInteger.TEN.pow(hugeN);
        System.out.println("10 的 " + hugeN + " 次方 (BigInteger) 的位数是: " + hugeResult.toString().length());
    }
}

优点:

• 可以处理任意大的整数,没有溢出问题。
• 是处理超大幂运算的唯一可靠方法。

缺点:

• 性能比基本数据类型（int, long）慢。
• 代码相对复杂一些。

总结与选择建议

• 如果只是临时计算或用于科学计算,用 Math.pow()。
• 如果需要精确的整数且指数不大,用 (long) Math.pow()。
• 如果是在代码里写死一个常量,直接写 ..。
• 如果指数可能非常大,用 BigInteger。