Calcular el factorial en Java: tutorial paso a paso

Las matemáticas entran en conjunción con la programación por medio de situaciones como el cálculo de factorial en Java. Aunque no sepas matemáticas o te parezca un proceso complejo, es de lo más simple que hay y hoy en Keepcoding te lo demostraremos. ¡Aprendamos a calcular el factorial en Java de algún que otro número y emprendamos este viaje de conocimiento!

¿Qué es el factorial?

Antes de entrar en detalles sobre el factorial en Java, es de vital importancia saber a qué hacemos referencia cuando hablamos de factorial en matemáticas.

Pues bien, el factorial de un número entero no negativo n se denota como n! y se calcula multiplicando todos los números enteros desde 1 hasta n. Unos ejemplos simples para que entiendas de qué va esto:

• 0! = 1
• 1! = 1
• 2! = 2 x 1 = 2
• 3! = 3 x 2 x 1 = 6
• 4! = 4 x 3 x 2 x 1 = 24
• 5! = 5 x 4 x 3 x 2 x 1 = 120

Cómo calcular el factorial en Java

Existen diferentes modos de calcular el factorial en Java. Veamos algunas formas:

Con el bucle for

Usar el bucle for es la forma más simple de calcular el factorial en Java. Veamos por qué:

import java.util.Scanner;

public class FactorialJava {
    public static void main(String[] args) {
        int n;
        double factorial = 1;
        Scanner sc = new Scanner(System.in);

        do {
            System.out.print("Introduce un número entero >= 0: ");
            n = sc.nextInt();
        } while (n < 0);

        for (int i = 1; i <= n; i++) {
            factorial *= i;
        }

        System.out.printf("%d! = %.0f %n", n, factorial);
    }
}

En este ejercicio hemos seguido una serie de pasos:

• Solicitamos al usuario que introduzca un número entero mayor o igual a 0.
• Utilizamos un bucle for para calcular el factorial.
• Imprimimos el resultado utilizando printf.

La salida del programa dependerá del número entero no negativo que introduzcas. Si, por ejemplo, introduces 5, el resultado será:

Introduce un número entero >= 0: 5
5! = 120

Por medio de la recursividad

La recursividad es otra de las formas de calcular el factorial en Java. Observemos un ejemplo de cómo hacerlo:

public class FactorialRecursivo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduce un número entero >= 0: ");
        int n = sc.nextInt();
        System.out.printf("%d! = %.0f %n", n, factorial(n));
    }

    public static double factorial(int n) {
        if (n <= 1) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }
}

Aquí:

• Definimos un método factorial que llama a sí mismo hasta que n es menor o igual a 1.
• La condición base de la recursión es n <= 1, donde retornamos 1.

La salida de este ejemplo funciona igual que la anterior, ya que dependerá del número que se introduzca en la entrada del teclado.

¿Cuál es la diferencia entre el bucle for y la recursividad?

Tanto la recursividad como el bucle for son grandes técnicas para calcular el factorial en Java, pero tienen sus diferencias:

• Bucle for: Es fácil de entender y eficiente para números pequeños. Sin embargo, puede no ser adecuado para números muy grandes debido a las limitaciones del tipo de datos int y double.
• Recursividad: Es elegante y concisa, pero puede ser menos eficiente debido a las llamadas de función adicionales. Además, puede llevar a un desbordamiento de la pila si n es demasiado grande.

Implementar un método factorial reutilizable

Una de las buenas prácticas en programación es encapsular la lógica del cálculo del factorial en un método separado. ¿Suena complicado? Ya mismo te demostramos que no es así:

import java.util.Scanner;

public class CalcularFactorial {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduce un número entero >= 0: ");
        int n = sc.nextInt();
        System.out.printf("%d! = %.0f %n", n, factorial(n));
    }

    public static double factorial(int n) {
        double fact = 1;
        for (int i = 1; i <= n; i++) {
            fact *= i;
        }
        return fact;
    }
}

Este tipo de implementación nos ofrece diferentes ventajas, entre ellas:

• El método factorial puede ser reutilizado en diferentes partes del programa.
• El código es más modular y fácil de mantener.

Uso de BigInteger para grandes números

Existirán ocasiones en las que el tipo double no será suficiente para números muy grandes debido a la limitación de su rango. En estos casos, lo que podemos hacer es usar BigInteger:

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

public class FactorialBigInteger {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Introduce un número entero >= 0: ");
        int n = sc.nextInt();
        System.out.printf("%d! = %s %n", n, factorial(n).toString());
    }

    public static BigInteger factorial(int n) {
        BigInteger fact = BigInteger.ONE;
        for (int i = 1; i <= n; i++) {
            fact = fact.multiply(BigInteger.valueOf(i));
        }
        return fact;
    }
}

Justo en este ejemplo hemos usado BigInteger para manejar números muy grandes sin perder precisión. Funciona igual que los ejemplos anteriores, solo que para este caso podemos usar números grandes y sin temor a sufrir un desbordamiento de pila.

Como pudiste observar, calcular el factorial en Java es súper sencillo e incluso más simple es entender el concepto matemático. Por eso queremos hacerte la invitación a que sigas aprendiendo por medio de nuestro bootcamp en java, con el cual pulirás tus habilidades en este lenguaje de programación y podrás acceder a mejores ofertas de empleo en el sector techie. ¿Qué esperas para unirte y cambiar tu futuro ya mismo?