有没有一种方法可以计算Java中的阶乘？

Question

我还没找到它.我错过了什么？我知道一个阶乘方法是初学者的常见示例程序.但是,重新使用这个标准实现是不是很有用？我可以使用标准类型(int,long ...)和BigInteger/BigDecimal这样的方法.

Answer 1

Apache Commons Math在MathUtils类中有一些阶乘方法.

Answer 2

public class UsefulMethods {
    public static long factorial(int number) {
        long result = 1;

        for (int factor = 2; factor <= number; factor++) {
            result *= factor;
        }

        return result;
    }
}

HoldOffHunger的 Big Numbers版本:

public static BigInteger factorial(BigInteger number) {
    BigInteger result = BigInteger.valueOf(1);

    for (long factor = 2; factor <= number.longValue(); factor++) {
        result = result.multiply(BigInteger.valueOf(factor));
    }

    return result;
}

Answer 3

我不认为为factorial提供库函数会有用.对有效的因子实现进行了大量研究.这是一些实现.

Answer 4

在实践中很少需要裸露的裸体因子.大多数情况下,您将需要以下之一:

1)将一个因子除以另一个因子,或

2)近似浮点答案.

在这两种情况下,您都可以使用简单的自定义解决方案.

在情况(1)中,例如,如果x = 90!/ 85!,然后你将计算结果就像x = 86*87*88*89*90,而不需要保持90!在记忆中 :)

在情况(2)中,谷歌为"斯特林的近似".

Answer 5

使用番石榴BigIntegerMath如下:

BigInteger factorial = BigIntegerMath.factorial(n);

(对于类似的功能int和long是在可用的IntMath和LongMath分别).

Answer 6

Apache Commons Math包有一个阶乘方法,我想你可以使用它.

Answer 7

简短的回答是:使用递归.

您可以创建一个方法并在同一方法内递归调用该方法:

public class factorial {

    public static void main(String[] args) {
        System.out.println(calc(10));
    }

    public static long calc(long n) {
        if (n <= 1)
            return 1;
        else
            return n * calc(n - 1);
    }
}

Answer 8

我相信这将是最快的方式,通过查找表:

private static final long[] FACTORIAL_TABLE = initFactorialTable();
private static long[] initFactorialTable() {
    final long[] factorialTable = new long[21];
    factorialTable[0] = 1;
    for (int i=1; i<factorialTable.length; i++)
        factorialTable[i] = factorialTable[i-1] * i;
    return factorialTable;
}
/**
 * Actually, even for {@code long}, it works only until 20 inclusively.
 */
public static long factorial(final int n) {
    if ((n < 0) || (n > 20))
        throw new OutOfRangeException("n", 0, 20);
    return FACTORIAL_TABLE[n];
}

对于本机类型long(8字节),它只能容纳20!

20! = 2432902008176640000(10) = 0x 21C3 677C 82B4 0000

显然21!会导致溢出.

因此,对于本机类型long,只20!允许最大值,有意义且正确.

Answer 9

因为阶乘增长如此之快,如果使用递归,堆栈溢出不是问题.其实价值20!是Java中可以代表的最长的一个.因此,如果n太大,以下方法将计算factorial(n)或抛出IllegalArgumentException.

public long factorial(int n) {
    if (n > 20) throw new IllegalArgumentException(n + " is out of range");
    return (1 > n) ? 1 : n * factorial(n - 1);
}

另一种(更酷)的方法是使用Java 8的流库,如下所示:

public long factorial(int n) {
    if (n > 20) throw new IllegalArgumentException(n + " is out of range");        
    return LongStream.rangeClosed(1, n).reduce(1, (a, b) -> a * b);
}

阅读使用Java 8流的Factorials的更多信息

Answer 10

虽然阶乘对初学程序员来说是一个很好的练习,但在大多数情况下它们并不是很有用,而且每个人都知道如何编写阶乘函数,所以它们通常不在普通的库中.