Factorial Program in Java | Java Program to Find Factorial

Introduction

Java is one of the popular languages. It has gained a lot of craze among the programmers because of its platform independence. Java proves itself flexible in web developers’ view and user-friendly in programmers because they can deploy an application developed in this programming language in all operating systems.

The object-oriented feature of Java provides many ways to reach the pristine code shore and offer good readability. Also, code reusability is simple in Java and avoids code duplication. Along with that, Java provides many predefined methods and libraries for a smooth workflow.

Now coming to our point, we will discuss the implementation of factorial of a number in Java. Many of you might know how to calculate the factorial of a number, but for the people who are new to the term, factorial lets quickly have a look at calculating the factorial of a number.

Check out our free courses to get an edge over the competition.

The symbol denotes the factorial of a number “! “, so the factorial of an integer can denote by n!. And it is equal to the product of all numbers between 1 to n. For example, the factorial of 5 is 120 (1x2x3x4x5).

Factorial Program in Java and its Types

Factorial is a fundamental mathematical operation used in many algorithms and computations.Let’s start by writing a factorial program in Java using an iterative approach. The factorial of a non-negative integer n, denoted as n!, is the product of all positive integers less than or equal to n.

import java.util.Scanner;
public class FactorialProgram {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int number = scanner.nextInt();
        int factorial = 1;
        for (int i = 1; i <= number; i++) {
            factorial *= i;
        }
        System.out.println("Factorial of " + number + " is: " + factorial);
        scanner.close();
    }
}

</> Copy Code

In this program, we take input from the user using the Scanner class. We initialize the factorial variable to 1 and then use a for loop to multiply all the numbers from 1 to the given number. Finally, we display the factorial.

Factorial Program in Java Script

Similarly, we can write a factorial program in Java Script using an iterative approach. JavaScript provides a concise syntax for such programs.

function factorial(number) {
    let factorial = 1;
    for (let i = 1; i <= number; i++) {
        factorial *= i;
    }
    return factorial;
}
let number = parseInt(prompt("Enter a number: "));
let result = factorial(number);
console.log(`Factorial of ${number} is: ${result}`);

</> Copy Code

In this JavaScript program, we define a function called factorial that takes a number as input. We then initialize the factorial variable to 1 and use a for loop to calculate the factorial. Finally, we display the factorial using the console.log() function.

Factorial Using Recursion in Java

Recursion is a powerful programming technique where a method calls itself to solve a problem. Let’s explore how we can calculate factorial using recursion in Java.

import java.util.Scanner;
public class FactorialProgram {
    public static int factorial(int number) {
        if (number == 0 || number == 1) {
            return 1;
        } else {
            return number * factorial(number - 1);
        }
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter a number: ");
        int number = scanner.nextInt();
        int result = factorial(number);
        System.out.println("Factorial of " + number + " is: " + result);
        scanner.close();
    }
}

</> Copy Code

In this program, we define a recursive function called factorial that takes a number as input. The base case is when the number is 0 or 1, where the factorial is always 1. For any other number, the factorial is calculated by multiplying the number with the factorial of the number minus one. This process continues until we reach the base case.

Therefore, we have explored three different ways to write a factorial program in Java and its variants: an iterative approach using a for loop, an iterative approach using Javascript, and a factorial using recursion in Java. Understanding how these programs work can help you create more efficient algorithms to solve complex problems.

Recursive Solution

Let us walk through a recursive java program!

import java.util.*;
public class UpGrad{
    public static int factorial(int n){
        if(n==1 || n==0)
            return 1;
        return n*factorial(n-1);
    }
 public static void main(String[] args) {
 Scanner sc=new Scanner(System.in);
 int n=sc.nextInt();
 System.out.print("factorial of "+n+" is "+factorial(n));
 }
}

</> Copy Code

In the above code, we’ve created a class and implemented a method factorial that expects an integer as a parameter and returns that number factorial. We have a base case that returns one if the given number is equal to 0 or 1 because factorial of 0 and 1 are 1.

Check out upGrad’s Full Stack Development Bootcamp (JS/MERN)

Later, we recursively call the factorial of the preceding numbers by multiplying the current number to the prior number factorial. Later we have a primary method and a scanner object instantiated in it. We read the integer n from user input and call the factorial way bypassing the user input as the parameter. And finally, we are printing the factorial onto the screen.

We can further minimize the factorial method’s size, which we’ve implemented in the above code. We can use a ternary operator to don’t even need an if block and finish the single line implementation. And here’s the code to do that.

public static int factorial(int n){
        return n>1?n*factorial(n-1):1;
    }
public static void main(String[] args) {
 Scanner sc=new Scanner(System.in);
 int n=sc.nextInt();
 System.out.print("factorial of "+n+" is "+factorial(n));
}

</> Copy Code

Check out upGrad’s Java Bootcamp.  

But few of the programmers prefer an iterative solution over a recursive solution. Because the execution flow is frequently interrupted in a recursive implementation, let us walk through an iterative solution to find a number factor.