Factorial Program in Java: Know How to Master It in 2025

Posted on March 21, 2025, by Ashutosh Singh

If you’ve searched for “factorial program in Java”, you’re likely eager to tackle one of programming’s foundational challenges using a powerful, widely-used language. As of March 21, 2025, Java remains a top choice for developers, and writing a factorial program is an excellent way to sharpen your coding skills. Whether you’re a beginner learning loops and recursion or an intermediate coder exploring optimization techniques, this guide will walk you through everything you need to know about creating a factorial program in Java.

From basic implementations to handling large numbers with BigInteger, we’ll provide clear code examples, explain each approach step-by-step, and dive into real-world applications. By the end, you’ll be equipped to compute factorials efficiently and confidently. Let’s dive into the world of factorial programs in Java and get started!

What Is a Factorial?

Before we write any code, let’s define a factorial. The factorial of a non-negative integer n, denoted as n!, is the product of all positive integers from 1 to n. Mathematically:

• n! = n × (n-1) × (n-2) × … × 2 × 1
• Special cases: 0! = 1 and 1! = 1

Examples:

• 5! = 5 × 4 × 3 × 2 × 1 = 120
• 3! = 3 × 2 × 1 = 6
• 0! = 1

Factorials grow rapidly—10! = 3,628,800—making them a fascinating subject for programming exercises and a common topic in mathematics, combinatorics, and computer science.

Why Write a Factorial Program in Java?

Java’s robustness, readability, and support for large numbers make it ideal for factorial calculations. Writing a factorial program in Java helps you:

• Practice iteration and recursion.
• Understand data type limits and overflow handling.
• Build problem-solving skills for technical interviews.
• Explore real-world applications like permutations and probability.

Basic Factorial Program in Java (Iterative Approach)

Let’s start with a simple iterative program to calculate the factorial of a number:

javaCollapseWrapCopy

import java.util.Scanner; public class FactorialIterative { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter a number: "); int n = scanner.nextInt(); long result = factorial(n); if (result == -1) { System.out.println("Factorial is not defined for negative numbers."); } else { System.out.println("Factorial of " + n + " is: " + result); } scanner.close(); } public static long factorial(int n) { if (n < 0) { return -1; // Invalid input } if (n == 0 || n == 1) { return 1; } long fact = 1; for (int i = 2; i <= n; i++) { fact *= i; } return fact; } }

How It Works

1. Input: Takes a user-entered number n.
2. Logic:
   • Returns -1 for negative numbers (factorial isn’t defined).
   • Returns 1 for 0 or 1.
   • Uses a for loop to multiply numbers from 2 to n.
3. Output: Prints the result.

Sample Output:

textCollapseWrapCopy

Enter a number: 5 Factorial of 5 is: 120

textCollapseWrapCopy

Enter a number: -3 Factorial is not defined for negative numbers.

Note: Uses long to handle larger factorials (up to 20!), but overflows beyond that.

Factorial Program Using Recursion in Java

Recursion mirrors the mathematical definition of factorial. Here’s how:

javaCollapseWrapCopy

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

How It Works

1. Base Cases: Returns 1 for 0 or 1, -1 for negatives.
2. Recursive Case: Computes n! = n × (n-1)!.
3. Stack: Each call builds a stack, resolved backward (e.g., 5! = 5 × 4! → 5 × 24 = 120).

Output:

textCollapseWrapCopy

Enter a number: 6 Factorial of 6 is: 720

Drawback: Recursion risks stack overflow for large n (e.g., >1000) and is less efficient than iteration (O(n) time, O(n) space).

Handling Large Factorials with BigInteger in Java

Factorials grow exponentially, exceeding long’s limit (2^63-1) by 21!. Use BigInteger for unlimited size:

javaCollapseWrapCopy

import java.util.Scanner; import java.math.BigInteger; public class FactorialBigInteger { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter a number: "); int n = scanner.nextInt(); BigInteger result = factorial(n); if (result.equals(BigInteger.valueOf(-1))) { System.out.println("Factorial is not defined for negative numbers."); } else { System.out.println("Factorial of " + n + " is: " + result); } scanner.close(); } public static BigInteger factorial(int n) { if (n < 0) { return BigInteger.valueOf(-1); } if (n == 0 || n == 1) { return BigInteger.ONE; } BigInteger fact = BigInteger.ONE; for (int i = 2; i <= n; i++) { fact = fact.multiply(BigInteger.valueOf(i)); } return fact; } }

How It Works

• Uses BigInteger for arbitrary-precision arithmetic.
• Multiplies incrementally using multiply().

Output:

textCollapseWrapCopy

Enter a number: 25 Factorial of 25 is: 15511210043330985984000000

Advantage: Handles massive factorials (e.g., 100!) without overflow.

Recursive Factorial with BigInteger

For a recursive approach with large numbers:

javaCollapseWrapCopy

import java.util.Scanner; import java.math.BigInteger; public class FactorialBigIntegerRecursive { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter a number: "); int n = scanner.nextInt(); BigInteger result = factorial(n); if (result.equals(BigInteger.valueOf(-1))) { System.out.println("Factorial is not defined for negative numbers."); } else { System.out.println("Factorial of " + n + " is: " + result); } scanner.close(); } public static BigInteger factorial(int n) { if (n < 0) { return BigInteger.valueOf(-1); } if (n == 0 || n == 1) { return BigInteger.ONE; } return BigInteger.valueOf(n).multiply(factorial(n - 1)); } }

Output:

textCollapseWrapCopy

Enter a number: 30 Factorial of 30 is: 265252859812191058636308480000000

Optimizing Factorial Programs in Java

Efficiency matters for large inputs. Here’s how to optimize:

1. Iterative vs. Recursive

• Iterative: O(n) time, O(1) space—faster and stack-safe.
• Recursive: O(n) time, O(n) space—elegant but risks stack overflow.

2. Use BigInteger for Large Numbers

• Prevents overflow beyond 20! (for long).

3. Tail Recursion (Limited Benefit in Java)

Java doesn’t optimize tail recursion, but here’s an example:

javaCollapseWrapCopy

public static long factorialTail(int n, long accumulator) { if (n < 0) return -1; if (n == 0 || n == 1) return accumulator; return factorialTail(n - 1, n * accumulator); }

Call: factorialTail(5, 1) yields 120.

4. Precompute Small Factorials

Store factorials up to 20 in an array for quick lookups:

javaCollapseWrapCopy

public static long[] precomputed = {1, 1, 2, 6, 24, 120, /* ... */};

Factorial Program with User Input Validation

Handle edge cases robustly:

javaCollapseWrapCopy

import java.util.Scanner; public class FactorialWithValidation { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n; while (true) { System.out.print("Enter a number (0-20): "); try { n = scanner.nextInt(); if (n < 0 || n > 20) { System.out.println("Please enter a number between 0 and 20."); continue; } break; } catch (Exception e) { System.out.println("Invalid input. Enter an integer."); scanner.next(); // Clear invalid input } } long result = factorial(n); System.out.println("Factorial of " + n + " is: " + result); scanner.close(); } public static long factorial(int n) { if (n == 0 || n == 1) return 1; long fact = 1; for (int i = 2; i <= n; i++) { fact *= i; } return fact; } }

Output:

textCollapseWrapCopy

Enter a number (0-20): -5 Please enter a number between 0 and 20. Enter a number (0-20): abc Invalid input. Enter an integer. Enter a number (0-20): 7 Factorial of 7 is: 5040

Features: Handles negatives, non-integers, and limits range to avoid overflow.

Real-World Applications of Factorial Programs

Factorials aren’t just academic—they’re practical:

• Combinatorics: Calculate permutations (n!) and combinations (n! / (r! × (n-r)!)).
• Probability: Used in statistical models (e.g., binomial coefficients).
• Algorithms: Factorials appear in recursive problems and dynamic programming.
• Testing: Benchmarks performance for large computations.

Common Pitfalls and Debugging Tips

Avoid these errors:

1. Overflow: Use BigInteger for n > 20.
2. Negative Inputs: Validate with if (n < 0).
3. Stack Overflow: Limit recursion depth or use iteration.
4. Input Errors: Use try-catch for non-integer inputs.

Comparing Iterative and Recursive Approaches

Verdict: Iterative is preferred for performance; recursive for learning.

Factorial Program with Array Storage

Store factorials in an array:

javaCollapseWrapCopy

import java.util.Scanner; public class FactorialArray { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.print("Enter the number of terms (up to 20): "); int n = scanner.nextInt(); long[] factorials = new long[n + 1]; factorials[0] = 1; for (int i = 1; i <= n; i++) { factorials[i] = factorials[i - 1] * i; } System.out.println("Factorials from 0 to " + n + ":"); for (int i = 0; i <= n; i++) { System.out.println(i + "! = " + factorials[i]); } scanner.close(); } }

Output:

textCollapseWrapCopy

Enter the number of terms (up to 20): 5 Factorials from 0 to 5: 0! = 1 1! = 1 2! = 2 3! = 6 4! = 24 5! = 120

Frequently Asked Questions About Factorial Programs in Java

What Is a Factorial Program in Java?

A program that calculates the factorial of a number using Java code.

How Do I Handle Large Factorials?

Use BigInteger to avoid overflow.

Is Recursion Better Than Iteration?

Iteration is more efficient; recursion is more intuitive.

What’s the Limit of Factorial with long?

20!—beyond that, use BigInteger.

Why Learn Factorials in Java?

It builds skills for math, recursion, and real-world applications.

Conclusion: Mastering Factorial Programs in Java

Writing a factorial program in Java is a rewarding journey through logic, mathematics, and coding. From basic loops to BigInteger for massive numbers, you’ve now got a toolkit to compute factorials in any context. Whether you’re prepping for an interview, tackling a school project, or exploring Java’s capabilities, these skills will serve you well in 2025.