Java 中计算阶乘的方法

  2. 贴士文章
  3. Java 贴士
  4. Java 中计算阶乘的方法
Mohammad Irfan 2023年10月12日
Java Java Math
  1. 使用 Java 中的迭代方法获取阶乘
  2. 在 Java 中使用递归方法查找阶乘
  3. 在 Java 中使用动态方法查找阶乘
  4. 在 Java 中使用 Apache Commons 查找阶乘
  5. 使用 Java 8 流查找阶乘
  6. 在 Java 中使用 BigInteger 查找阶乘
  7. 使用 BigIntegerMath 库查找阶乘
Java 中计算阶乘的方法

本教程介绍了在 Java 中计算阶乘的方法和代码示例。

数 n 的阶​​乘是 1 和 n 之间所有自然数的乘积。在本教程中，我们将看到计算数字阶乘的不同方法。

我们将首先看看如何计算小于等于 20 的数字的阶乘。这种隔离是因为 Java 的长数据类型范围有限。

20 以上数字的阶乘太大而无法放入多头的范围内。

使用 Java 中的迭代方法获取阶乘

在这个例子中，我们创建了一个 long 类型的变量 store_fact，并使用 1 对其进行初始化。

然后我们遍历从 1 到计算阶乘的所有整数，并将循环变量值乘以 store_fact 值。我们将计算值存储到 store_fact 变量中并更新循环变量。

为了让上面的算法更清晰，我们可以这样写：

  • 初始化 n
  • 初始化 store_fact = 1
  • 执行 for i = 1 到 n
  • store_fact = store_fact*n
  • 增加 i
  • 返回 store_fact

在上面的算法中，store_fact 变量存储 n 的阶​​乘如下：

  • 第一次迭代后：store_value = 1 = 1!
  • 第二次迭代后：store_value = 1 X 2 = 2!
  • 第三次迭代后：store_value = 1 X 2 X 3 = 3!
  • 第 n 次迭代后：store_value = 1 X 2 X 3 X 4 ........ Xn = n!

现在让我们看一下上述算法的代码示例。

import java.util.Scanner;
public class SimpleTesting {
  static long factCalculator(int n) {
    long store_fact = 1;
    int i = 1;
    while (i <= n) {
      store_fact = store_fact * i;
      i++;
    }
    return store_fact;
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

输出：

Enter a number: 
4
24

在 Java 中使用递归方法查找阶乘

上面的迭代方法可以转化为递归方法来求任意数的阶乘。在这种方法中，我们将基本情况视为：

if (n == 0 || n == 1) {
  return 1;
}

如果不满足基本条件，则返回：

n* factCalculator(n - 1);

让我们看看下面的代码示例。我们使用递归方法 factCalculator() 来查找阶乘。

import java.util.*;
public class SimpleTesting {
  static long factCalculator(int n) {
    if (n == 0 || n == 1) {
      return 1;
    } else {
      return n * factCalculator(n - 1);
    }
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

输出：

Enter a number:
4
24

在 Java 中使用动态方法查找阶乘

我们还可以使用动态规划方法计算数字的阶乘。此方法比其他方法更快，因为它存储较小数字的阶乘并使用这些阶乘计算较大数字的阶乘。

例如：

  • 5! = 5 X 4!
  • 4! = 4 X 3!
  • 3! = 3 X 2!
  • 2! = 2 X 1!
  • 1! = 1 X 0!
  • 0! = 1

在这个方法中，我们创建了一个查找表。该表存储从 0 到 20 的数字的阶乘。

我们创建直到 20 的查找表只是因为它是阶乘 long 可以存储的最大数。我们初始化了 0!作为 1。

然后我们使用值 0!计算 1!，1!的值计算 2!等等。看下面的代码：

import java.util.*;
public class SimpleTesting {
  static long[] factCalculator() {
    long[] fact_table = new long[21];
    fact_table[0] = 1;
    for (int i = 1; i < fact_table.length; i++) {
      fact_table[i] = fact_table[i - 1] * i;
    }
    return fact_table;
  }
  public static void main(String args[]) {
    long[] table = factCalculator();
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(table[number]);
  }
}

输出：

Enter a number: 
5
120

在 Java 中使用 Apache Commons 查找阶乘

如果你使用 Apache Commons Math 库，请使用带有 factorial() 方法的 CombinatoricsUtils 类。它是计算任何数字的阶乘的内置方法。

该方法返回的值为 long 类型；因此，我们无法计算大于 20 的数字的阶乘。请参见下面的示例。

import java.util.Scanner;
import org.apache.commons.math3.util.CombinatoricsUtils;
public class SimpleTesting {
  static long factCalculator(int n) {
    return CombinatoricsUtils.factorial(n);
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

输出：

Enter a number: 
5
120

使用 Java 8 流查找阶乘

我们还可以使用 Java 8 流 API 来计算数字的阶乘。我们将首先创建一个从 1 到 n 的数字流，其中 n 是计算其阶乘的数字。

然后我们使用 reduce 方法对元素执行归约操作。我们将 1 作为单位元素，将乘法作为关联累加函数。

看下面的代码：

import java.util.*;
import java.util.stream.LongStream;
public class SimpleTesting {
  static long factCalculator(int n) {
    return LongStream.rangeClosed(1, n).reduce(1, (long num1, long num2) -> num1 * num2);
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

输出：

Enter a number: 
5
120

与迭代或递归方法相比，使用 reduce() 函数有一个很大的优势。如果用于处理元素的函数是关联的，则 reduce() 操作是可并行化的。

现在，我们将计算 20 以上数字的阶乘。

在 Java 中使用 BigInteger 查找阶乘

BigInteger 类用于处理超出原始数据类型范围的非常大的数字。我们可以使用 BigInteger 来存储 20 以上数字的阶乘值。

请参见下面的示例。

import java.math.BigInteger;
import java.util.Scanner;

public class SimpleTesting {
  static BigInteger factCalculator(int n) {
    BigInteger store_fact = BigInteger.ONE;
    for (int i1 = 2; i1 <= n; i1++) {
      store_fact = store_fact.multiply(BigInteger.valueOf(i1));
    }
    return store_fact;
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
    scan.close();
  }
}

输出：

Enter a number:
50
30414093201713378043612608166064768844377641568960512000000000000

由于我们不能使用*运算符来乘以 BigInteger，所以我们使用 multiply() 函数。这个方法和迭代方法一样，只是我们使用 BigInteger 而不是 long。

使用 BigIntegerMath 库查找阶乘

BigIntegerMath 库有一个内置的 factorial() 方法，可用于计算数字的阶乘。它是一个静态方法并返回一个 long 类型的值。

请参见下面的示例。

import com.google.common.math.BigIntegerMath;
import java.util.*;
public class SimpleTesting {
  static long factCalculator(int n) {
    return BigIntegerMath.factorial(n);
  }
  public static void main(String args[]) {
    int number;
    Scanner scan = new Scanner(System.in);
    System.out.println("Enter a number: ");
    number = scan.nextInt();
    System.out.println(factCalculator(number));
  }
}

输出：

Enter a number:
50
30414093201713378043612608166064768844377641568960512000000000000

相关文章 - Java Math