以Java计算能力
在Java中有没有其他的方式来计算一个整数的幂？ 我现在使用Math.pow（a，b），但是它返回一个double，这通常是很多工作，并且当你只想使用整数时看起来不那么干净（一个权力总是会导致一个整数） 。
Python中有没有像Python那样简单的东西？
整数只有32位。 这意味着它的最大值是2 ^ 31 -1。 正如你所看到的，对于非常小的数字，你很快就会有一个不能用整数表示的结果。 这就是为什么Math.pow使用双。
如果你想要任意的整数精度，使用BigInteger.pow 。 但它当然效率较低。
最好的algorithm是基于a ^ b的recursion功率定义。
long pow (long a, int b) { if ( b == 0) return 1; if ( b == 1) return a; if (isEven( b )) return pow ( a * a, b/2); //even a=(a^2)^b/2 else return a * pow ( a * a, b/2); //odd a=a*(a^2)^b/2 }
运行的运行时间是O（logb）。 参考： 更多信息
不，没有什么比a**b短
这是一个简单的循环，如果你想避免双打：
long result = 1; for (int i = 1; i <= b; i++) { result *= a; }
如果要使用pow并将结果转换为整数，则按如下所示投射结果：
int result = (int)Math.pow(a, b);
谷歌番石榴有整数math实用程序。 IntMath
番石榴的math图书馆提供了两种方法，在计算确切的整数权力时很有用：
pow(int b, int k)计算b到k的权力，并包装溢出
checkedPow(int b, int k)除了在溢出时抛出ArithmeticException之外是相同的
就个人而言， checkedPow()满足了我对整数幂checkedPow()大部分需求，比使用double版本和四舍五入更清晰，更经济。在几乎所有需要function函数的地方，overflow都是一个错误（或者不可能，但是我想被告知是否不可能变得可能）。
如果你想得到一个long结果，你可以使用相应的LongMath方法并传递int参数。
那么您可以简单地使用Math.pow(a,b)就像之前使用的一样，只需在它之前使用(int)来转换它的值即可。 下面可以作为一个例子。
int x = (int) Math.pow(a,b);
其中a和b可以是你想要的double或者int值。 这将简单地将其输出转换为一个整数值，如你所需。
import java.util.*; public class Power { public static void main(String args[]) { Scanner sc=new Scanner(System.in); int num = 0; int pow = 0; int power = 0; System.out.print("Enter number: "); num = sc.nextInt(); System.out.print("Enter power: "); pow = sc.nextInt(); System.out.print(power(num,pow)); } public static int power(int a, int b) { int power = 1; for(int c=0;c<b;c++) power*=a; return power; } }
对于计算功率的重复平方algorithm实现一个简单的（不检查溢出或对参数的有效性）：
/** Compute a**p, assume result fits in a 32-bit signed integer */ int pow(int a, int p) { int res = 1; int i1 = 31 - Integer.numberOfLeadingZeros(p); // highest bit index for (int i = i1; i >= 0; --i) { res *= res; if ((p & (1<<i)) > 0) res *= a; } return res; }
时间复杂度是指数p的对数（即对于表示p所需的位数是线性的）。
我设法修改（边界，甚至检查，负数检查）Qx__答案。 使用风险自负。 0 ^ -1，0 ^ -2等。返回0。
private static int pow(int x, int n) { if (n == 0) return 1; if (n == 1) return x; if (n < 0) { // always 1^xx = 1 && 2^-1 (=0.5 --> ~ 1 ) if (x == 1 || (x == 2 && n == -1)) return 1; else return 0; } if ((n & 1) == 0) { //is even long num = pow(x * x, n / 2); if (num > Integer.MAX_VALUE) //check bounds return Integer.MAX_VALUE; return (int) num; } else { long num = x * pow(x * x, n / 2); if (num > Integer.MAX_VALUE) //check bounds return Integer.MAX_VALUE; return (int) num; } }
与Python（可以通过** b计算权力）不同，JAVA没有这样的快捷方式来完成两个数字的结果。 Java在Math类中有名为pow的函数，它返回一个Double值
double pow(double base, double exponent)
但是你也可以使用相同的函数来计算整数的幂。 在下面的程序中，我做了同样的事情，最后我将结果转换为一个整数（types转换）。 根据例子：
import java.util.*; import java.lang.*; // CONTAINS THE Math library public class Main{ public static void main(String[] args){ Scanner sc = new Scanner(System.in); int n= sc.nextInt(); // Accept integer n int m = sc.nextInt(); // Accept integer m int ans = (int) Math.pow(n,m); // Calculates n ^ m System.out.println(ans); // prints answers } }
或者， java.math.BigInteger.pow(int exponent)返回值为（this ^ exponent）的BigInteger。 指数是一个整数，而不是一个BigInteger。 例：
import java.math.*; public class BigIntegerDemo { public static void main(String[] args) { BigInteger bi1, bi2; // create 2 BigInteger objects int exponent = 2; // create and assign value to exponent // assign value to bi1 bi1 = new BigInteger("6"); // perform pow operation on bi1 using exponent bi2 = bi1.pow(exponent); String str = "Result is " + bi1 + "^" +exponent+ " = " +bi2; // print bi2 value System.out.println( str ); } }
