Java Factorial Program

Factorial of  number is the product of all numbers before it including the number itself, till 1. Factorial of 0 is 1.

In this article, we will learn many different ways to calculate factorial of a number with java program.

Method 1: Using while loop
Execute a loop starting from the number till 1.
Declare a variable to hold the factorial of this number. Initialize it to 1.

In every loop iteration,
A. multiply this variable with the number and store the result back to the variable.
B. Decrease the number by 1.

Thus, when the loop completes, the result variable will contain the product of number with all other numbers before it till 1, hence the factorial.

int num = 5;
int fact = 1;
while (num >= 1) {
  fact *= num;
  num--;
}

Method 2: Using for loop
Factorial of a number in java can also be calculated using a for loop.
In the last example, replace the while loop with a for loop, that runs from 1 till the number. Example,

int num = 5; 
int fact = 1; 
for(int i = 1; i <= num; i++) { 
  fact *= i; 
}

for loop will execute in forward direction from 1 till the number as opposed to while loop, which executed in reverse direction; from the number till 1.

Method 3: Recursive Method
Using a loop to execute repeated statements is called iterative approach.
Same result can be achieved using recursive approach. A recursive method invokes itself again and again.

Thus, instead of using a loop, we call the recursive method repeatedly and supply the number as argument.
Return value from this method is the product of the argument with another call to this method, with the argument decreased by 1. Example,

int factorial(int num) {
  // check if the argument is 1
  if (num == 1) {
    return 1;
  }
  // invoke method again
  return num * factorial(num - 1);
}

Recursive method will keep on calling itself till the argument becomes 1.
In every call, it will return the product of argument and a value which is 1 lesser than the argument.

Do not forget to check for argument equal to 1, else the recursive method will be stuck in an infinite loop, resulting in StackOverflowError.

Method 4: Using Java 8 streams
Java 8 streams can be used to calculate factorial of a number.

java.util.stream.IntStream class has a rangeClosed() method, which generates a stream of integers between a range. So, to calculate factorial of 5, we need to generate a stream of integers from 1 to 5.

Applying product operation on these integers using reduce() method will calculate factorial of 5. Example,

// this will always be 1
int start = 1;
// number whose factorial needs to be calculated
int number = 5;
int factorial = IntStream.rangeClosed(start, number)
                         .reduce((int x, int y) -> x * y)
                         .getAsInt();

reduce() method takes an object of type IntBinaryOperator as argument.

This is a functional interface having a single method applyAsInt() which takes two integer arguments and returns an integer.
So, we can supply a Lambda expression to reduce() which takes two integer arguments and returns their product.

reduce() will be invoked for integers from 1 to 5 and return their product, which will be the factorial of 5.

For larger numbers, use LongStream instead of IntStream.

Method 5: Using BigInteger
For calculating factorial of larger numbers, use java.math.BigInteger class, which can store values upto 2^Integer.MAX_VALUE.

BigInteger is analogous to java’s primitive int value with support for larger values. Since it is a class, we can call methods on this object.

Use a loop to calculate factorial using BigInteger.
To perform multiplication, use its multiply() method, which accepts a BigInteger argument and multiplies the argument value with the value on which multiply() is invoked. Example,

// result variable initialized to 1
BigInteger factorial = BigInteger.ONE;
// calcualte factorial of 60
int num = 60;
// loop from 60 to 1
while(num >= 1) {
  // multiply values
  factorial = factorial.multiply(BigInteger.valueOf(num));
  // decrease the number
  num--;
}

If you want the result as an int value, use intValue() method of BigInteger.

This method works the same as Method 1 and 2, except that we are using BigInteger in place of primitive int.
Method 6: Using Guava
Guava library has a class com.google.common.math.BigIntegerMath having method factorial(). This method accepts an integer value and returns its factorial. Example,

int number = 10;
BigInteger factorial = BigIntegerMath.factorial(number)

This method can be used to calculate factorial of larger values, since it returns the result as a BigInteger.
factorial() throws an IllegalArgumentException if the argument is negative.

To include Guava in your project, add below dependency as per the build tool
Gradle

implementation group: 'com.google.guava', name: 'guava', version: '30.1.1-jre'

Maven

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.1.1-jre</version>
</dependency>

Method 7: Using Apache Commons Math
Apache Commons Math library has org.commons.math3.util.CombinatoricsUtils class. This class has factorial() method which accepts an integer argument and returns its factorial as shown below

int number = 10;
long factorial = CombinatoricsUtils.factorial(number);

Note that returned value is of type long.

This class also has a method factorialDouble() which returns the factorial as a double value.

Add Apache Commons Math to your project using the below dependency.

Gradle

implementation group: 'org.apache.commons', name: 'commons-math3', version: '3.6.1'

Maven

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-math3</artifactId>
    <version>3.6.1</version>
</dependency>

That is all on different methods to calculate factorial of a number with java programs.
In all these methods, we used a fixed number but you may also take the number whose factorial needs to be calculated as user input from keyboard.
Simplest of these methods is using nextInt() method of Scanner class.

Below is a complete example code that reads a number as user input and calculates its factorial using a while loop.

Scanner scanner = new Scanner(System.in);
System.out.println("Enter a number");
int number = scanner.nextInt();
int fact = 1;
while (number >= 1) {
  fact *= number;
  number--;
}

Do not forget to click the clap.

1
Liked the article ? Spread the word...