Cuando estamos trabajando con aplicaciones Java, casi siempre son suficientes los tipos de datos primitivos como int y double, para trabajar con números. Pero… como “suficientes” no es suficiente, cuando se trata de números extremadamente grandes o fuera del rango permitido por estos datos primitivos, BigInteger en Java es un tipo de dato que se nos presenta para manejar estos casos. Veamos qué es el BigInteger en Java, cómo se usa y en qué ocasiones se debe usar.

¿Qué encontrarás en este post?

¿Qué es BigInteger en Java?

BigInteger es una clase del paquete java.math que ha sido diseñada específicamente para manejar números enteros que han excedido el límite de los tipos primitivos como int y long. Mientras que int puede almacenar valores entre -2,147,483,648 y 2,147,483,647, y long llega hasta los ±9 cuatrillones, el BigInteger en Java no tiene un límite en teoría, su única limitación va a ser la memoria disponible en el sistema.

Gracias a BigInteger en Java puedes realizar cálculos con números grandísimos sin tener que preocuparte por los desbordamientos que ocurren con los tipos primitivos.

¿Cuándo usar BigInteger?

Los tipos primitivos como int y long funcionan bien, pero no siempre pueden manejar todos los escenarios. Veamos aquellos casos en los que es mejor usar BigInteger:

Cálculos científicos o criptográficos: Al trabajar con números enormes, como claves criptográficas o cálculos astronómicos, los tipos primitivos pueden quedarse cortos.
Factoriales de grandes números: Calcular factoriales para números mayores a 20 genera resultados que sobrepasan fácilmente el rango de long.
Números muy grandes en finanzas: En aplicaciones financieras que manejan enormes cifras, BigInteger en Java asegura precisión en los cálculos sin pérdida de datos.

¿Cómo usar BigInteger en Java?

Si queremos usar BigInteger en Java, lo primero que tenemos que hacer es importar el paquete java.math.BigInteger. Una vez hecho esto, puedes crear un objeto de esta clase y utilizar los métodos que estén disponibles para hacer operaciones matemáticas.

Creación de un BigInteger

Puedes crear un objeto BigInteger a partir de una cadena que represente un número:

import java.math.BigInteger;

public class EjemploBigInteger {
    public static void main(String[] args) {
        BigInteger bigNumber = new BigInteger("123456789123456789");
        System.out.println("El número es: " + bigNumber);
    }
}

El resultado en consola sería el siguiente:

El número es: 123456789123456789

Operaciones básicas con BigInteger

El BigInteger en Java nos ofrece métodos para hacer las operaciones aritméticas básicas como son la suma, la resta, la multiplicación, la división y el módulo. Estas operaciones no se realizan con operadores matemáticos habituales, como son +, -, *, sino con métodos especiales. Veamos:

Suma y resta

Para sumar o restar números BigInteger, utilizamos los métodos add() y subtract():

BigInteger num1 = new BigInteger("1000000000000");
BigInteger num2 = new BigInteger("2500000000000");

BigInteger suma = num1.add(num2);
BigInteger resta = num2.subtract(num1);

System.out.println("Suma: " + suma);
System.out.println("Resta: " + resta);

El resultado en consola sería:

Suma: 3500000000000
Resta: 1500000000000

Multiplicación y división

Para multiplicar o dividir, se utilizan los métodos multiply() y divide():

BigInteger multiplicacion = num1.multiply(num2);
BigInteger division = num2.divide(num1);

System.out.println("Multiplicación: " + multiplicacion);
System.out.println("División: " + division);

El resultado de este código en consola sería:

Multiplicación: 2500000000000000000000000
División: 2

Cálculo del factorial con BigInteger

Una de las cosas para las que más se usa el BigInteger en Java es el cálculo de factoriales de números grandes, en donde los tipos primitivos fallan. Veamos:

import java.math.BigInteger;

public class FactorialBigInteger {
    public static void main(String[] args) {
        BigInteger resultado = factorial(new BigInteger("50"));
        System.out.println("Factorial de 50: " + resultado);
    }

    static BigInteger factorial(BigInteger n) {
        if (n.equals(BigInteger.ONE)) {
            return BigInteger.ONE;
        } else {
            return n.multiply(factorial(n.subtract(BigInteger.ONE)));
        }
    }
}

En este ejemplo, calculamos el factorial de 50 utilizando BigInteger, algo que sería imposible de hacer con tipos primitivos. El resultado sería el siguiente:

Factorial de 50: 30414093201713378043612608166064768844377641568960512000000000000

Otros métodos útiles de BigInteger

Existen muchos métodos que puedes usar con la clase BigInteger, aquí algunos de ellos:

pow(int exponent): Eleva un número BigInteger a una potencia.
mod(BigInteger m): Devuelve el resto de la división.
gcd(BigInteger val): Calcula el máximo común divisor entre dos números BigInteger.
isProbablePrime(int certainty): Verifica si el número es probablemente primo.

Ejemplo de BigInteger: varias operaciones

Para ilustrar mejor el proceso que se lleva a cabo con el BigInteger en Java, veamos un ejemplo de varias operaciones:

import java.math.BigInteger;

public class OperacionesBigInteger {
    public static void main(String[] args) {
        BigInteger big1 = new BigInteger("5000000000000");
        BigInteger big2 = new BigInteger("3000000000000");

        BigInteger suma = big1.add(big2);
        BigInteger resta = big1.subtract(big2);
        BigInteger multiplicacion = big1.multiply(big2);
        BigInteger division = big1.divide(big2);
        BigInteger mod = big1.mod(big2);

        System.out.println("Suma: " + suma);
        System.out.println("Resta: " + resta);
        System.out.println("Multiplicación: " + multiplicacion);
        System.out.println("División: " + division);
        System.out.println("Módulo: " + mod);
    }
}

En este código se meusstra cómo realizar las operaciones de suma, resta, multiplicación, división y módulo utilizando la clase BigInteger en Java. Esta clase es muy versátil y una opción perfecta para manipular números muy grandes sin perder precisión.

El resultado del código sería:

Suma: 8000000000000
Resta: 2000000000000
Multiplicación: 15000000000000000000000
División: 1
Módulo: 2000000000000

El programa realiza las siguientes operaciones con los números BigInteger big1 y big2:

Suma: 5000000000000 + 3000000000000 = 8000000000000
Resta: 5000000000000 - 3000000000000 = 2000000000000
Multiplicación: 5000000000000 * 3000000000000 = 15000000000000000000000
División: 5000000000000 / 3000000000000 = 1 (división entera)
Módulo: 5000000000000 % 3000000000000 = 2000000000000 (resto de la división)

Si el mundo de Java te apasiona y quieres aprender más sobre clases como BigInteger, inscríbete en el Bootcamp de java que tenemos en KeepCoding. En poco tiempo aprenderás sobre las herramientas necesarias para destacarte en el mercado laboral tecnológico, una industria en constante crecimiento que ofrece altos salarios y estabilidad profesional. ¡No esperes más y transforma tu vida!