Trabajando con Java puede suceder que en algún momento de nuestra vida necesitemos acceder a tipos de datos que cubran mayor longitud que un int o un long, por ejemplo. Es aquí cuando entra la clase BigInteger en Java, diseñada especialmente para manejar enteros de gran magnitud, como factoriales. Veamos un poco más a fondo de qué trata esta clase y cómo podemos usarla de la forma correcta.

¿Qué encontrarás en este post?

¿Qué es BigInteger en Java?

El BigInteger en Java es una clase que nos permite trabajar con números enteros de precisión arbitraria. Esto se diferencia de los tipos de datos primitivos como int o long, en tanto que los últimos tienen límites de tamaño, mientras que BigInteger tiene la capacidad de manejar números que no tienen más límites que los de la capacidad de memoria disponible. Esta clase es muy usada en aplicaciones que hagan uso de cálculos con números exageradamente grandes, como la criptografía, los cálculos científicos y financieros.

Algunas de las grandes ventajas de usar BigInteger en Java son:

Precisión arbitraria: La mayor ventaja del BigInteger en Java es su capacidad para manejar números de cualquier tamaño. Esta característica elimina las limitaciones impuestas por los tipos de datos primitivos y permite realizar cálculos con números que tienen cientos o, incluso, miles de dígitos.
Métodos utilitarios: BigInteger proporciona una amplia variedad de métodos para realizar operaciones aritméticas, cálculos de módulos, manipulación de bits y más. Algunos de los métodos más útiles incluyen:
- add(BigInteger val): Suma este BigInteger con el valor especificado.
- subtract(BigInteger val): Resta el valor especificado de este BigInteger.
- multiply(BigInteger val): Multiplica este BigInteger por el valor especificado.
- divide(BigInteger val): Divide este BigInteger por el valor especificado.
- mod(BigInteger val): Calcula el residuo de este BigInteger con el valor especificado.

Ejemplos de uso BigInteger en Java

Usar BigInteger en Java es relativamente sencillo, pero para que comprendas mejor su uso, veamos algunos ejemplos:

Calcular factoriales

El cálculo de factoriales es un buen ejemplo de dónde BigInteger es útil. Considera el siguiente código que calcula el factorial de 50 utilizando double:

public static void main(String[] args) {
    System.out.println(factorial(50));
}

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

Salida:

3.0414093201713376E64

No obstante, si intentamos calcular el factorial de un número más grande, como 200, el resultado será Infinity debido a la limitación de double.

Utilizando BigInteger, podemos calcular factoriales de números mucho más grandes:

import java.math.BigInteger;

public class CalcularFactorial {
    public static void main(String[] args) {
        System.out.println(factorial(new BigInteger("200")));
    }

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

Salida:

Un número extremadamente grande que no cabe en tipos primitivos.

Operaciones modulares

Otra aplicación común de BigInteger es en operaciones modulares, en especial en criptografía. Por ejemplo:

import java.math.BigInteger;

public class OperacionesModulares {
    public static void main(String[] args) {
        BigInteger a = new BigInteger("12345678901234567890");
        BigInteger b = new BigInteger("98765432109876543210");
        BigInteger m = new BigInteger("11223344556677889900");

        BigInteger resultado = a.modPow(b, m); // Calcula (a^b) % m
        System.out.println("Resultado: " + resultado);
    }
}

La operación modular exponencial a^b mod m es una forma eficiente de calcular grandes potencias de un número y luego tomar el residuo cuando se divide por otro número. En términos prácticos:

a^b: Calcula a elevado a la potencia de b.
a^b % m: Toma el resultado de a^b y lo divide por m, luego devuelve el residuo de esa división.

Estas operaciones se usan mucho en algoritmos criptográficos, como RSA, donde trabajar con números extremadamente grandes es una necesidad, pero hacerlo de manera eficiente es también importante.

Comparaciones y manipulación de bits

BigInteger también permite realizar comparaciones y manipular bits de manera eficiente:

import java.math.BigInteger;

public class ComparacionesYBits {
    public static void main(String[] args) {
        BigInteger num1 = new BigInteger("123456789");
        BigInteger num2 = new BigInteger("987654321");

        // Comparación
        if (num1.compareTo(num2) < 0) {
            System.out.println(num1 + " es menor que " + num2);
        } else {
            System.out.println(num1 + " es mayor o igual que " + num2);
        }

        // Manipulación de bits
        BigInteger bitwiseAnd = num1.and(num2);
        System.out.println("AND bit a bit: " + bitwiseAnd);
    }
}

Aquí se utiliza compareTo para comparar dos BigInteger y and para realizar una operación AND bit a bit entre dos números grandes.

La manipulación de bits se realiza utilizando el método and de la clase BigInteger.

and(BigInteger val): Realiza una operación AND bit a bit entre este BigInteger y el valor especificado. En una operación AND bit a bit, cada bit del resultado es 1 si ambos bits correspondientes de los operandos son 1, de lo contrario, el bit es 0.

La operación num1.and(num2) realiza una comparación bit a bit entre los valores binarios de num1 y num2.

Esta clase BigInteger en Java es tremendamente útil en muchas aplicaciones, como pudiste ver. Si te interesa el tema y quieres seguir aprendiendo sobre Java y otros lenguajes de programación, únete al bootcamp en java, en donde te guiaremos a través de los conceptos, la teoría y la práctica para que consigas estabilidad laboral que pocos sectores pueden ofrecer. ¡Únete ahora a la mejor comuidad!