Java Academy · Lección

Aritmética de enteros y desbordamiento

Comprenda la división entera, el módulo, el comportamiento del desbordamiento y cómo detectarlo.

Aritmética de enteros y desbordamiento es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Aritmética de enteros y desbordamiento

Los enteros de Java tienen tamaños fijos. Cuando un cálculo supera el valor máximo o mínimo, se desborda de forma silenciosa: no se lanza ninguna excepción. Comprender este comportamiento ayuda a evitar errores sutiles.

Rangos de los enteros

Cada tipo entero tiene un rango limitado determinado por su número de bits:

byte: -128 a 127
short: -32.768 a 32.767
int: -2.147.483.648 a 2.147.483.647
long: -9,2 × 10^18 a 9,2 × 10^18

System.out.println(Integer.MAX_VALUE); // 2147483647
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Long.MAX_VALUE);    // 9223372036854775807
System.out.println(Byte.MAX_VALUE);    // 127

Desbordamiento: vuelta silenciosa al inicio

Sumar 1 a Integer.MAX_VALUE hace que el valor vuelva a Integer.MIN_VALUE. Esta es una operación en complemento a dos; Java no ofrece ninguna garantía ni lanza ninguna excepción.

int max = Integer.MAX_VALUE;
System.out.println(max + 1); // -2147483648 (overflow!)

byte b = 127;
b++;  // wraps to -128
System.out.println(b); // -128

// Real bug: counting votes in a large election with int
int votes = Integer.MAX_VALUE;
votes += 100; // silently wrong
System.out.println(votes); // negative number!

Detección de desbordamientos con Math.addExact

Java 8+ introdujo Math.addExact(), multiplyExact() y subtractExact(), que lanzan ArithmeticException cuando se produce un desbordamiento, en lugar de volver al inicio silenciosamente.

try {
    int result = Math.addExact(Integer.MAX_VALUE, 1);
} catch (ArithmeticException e) {
    System.out.println("Overflow detected!"); // prints this
}

try {
    long safe = Math.multiplyExact(100_000L, 100_000L);
    System.out.println(safe); // 10000000000
} catch (ArithmeticException e) {
    System.out.println("Multiply overflow");
}

División de enteros y módulo

La división de enteros trunca hacia cero. El operador % devuelve el resto con el signo del dividendo. Tenga cuidado con la división entre cero: lanza ArithmeticException.

System.out.println(10 / 3);    // 3 (not 3.33)
System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1 (sign follows dividend)
System.out.println(-10 % -3);  // -1

try {
    int x = 5 / 0; // ArithmeticException: / by zero
} catch (ArithmeticException e) {
    System.out.println(e.getMessage()); // / by zero
}

// Float division by zero gives Infinity, not exception
System.out.println(5.0 / 0); // Infinity

Aritmética con long para números grandes

Use long cuando los valores puedan superar el rango de int. Añada siempre L a los literales long para evitar un desbordamiento antes de la asignación.

// Bug: multiplication done as int, then widened
long wrong = 1_000_000 * 1_000_000;   // overflows int!
System.out.println(wrong); // -727379968 (wrong!)

// Fix: one operand is long
long correct = 1_000_000L * 1_000_000L;
System.out.println(correct); // 1000000000000

// Or cast first
long alsOk = (long) 1_000_000 * 1_000_000;
System.out.println(alsOk); // 1000000000000

Operadores de desplazamiento de bits

Los operadores de desplazamiento de bits son formas rápidas de multiplicar o dividir por potencias de 2:

n << k — desplazamiento a la izquierda: multiplica por 2^k
n >> k — desplazamiento aritmético a la derecha: divide por 2^k
n >>> k — desplazamiento lógico a la derecha: rellena con ceros

int n = 8;
System.out.println(n << 1);  // 16 (8 * 2)
System.out.println(n << 2);  // 32 (8 * 4)
System.out.println(n >> 1);  // 4  (8 / 2)
System.out.println(n >> 2);  // 2  (8 / 4)

// Check if number is power of 2
boolean isPow2 = n > 0 && (n & (n - 1)) == 0;
System.out.println(isPow2); // true

AND, OR y XOR a nivel de bits

Los operadores a nivel de bits trabajan con bits individuales y se utilizan en permisos, indicadores y protocolos de bajo nivel.

int a = 0b1010; // 10
int b = 0b1100; // 12

System.out.println(Integer.toBinaryString(a & b)); // 1000 (AND = 8)
System.out.println(Integer.toBinaryString(a | b)); // 1110 (OR  = 14)
System.out.println(Integer.toBinaryString(a ^ b)); // 0110 (XOR = 6)
System.out.println(Integer.toBinaryString(~a));    // ...11110101 (NOT)

// Permission flags example
int READ  = 0b001;
int WRITE = 0b010;
int EXEC  = 0b100;
int perms = READ | WRITE; // user has read+write
System.out.println((perms & EXEC) != 0); // false — no exec

Guiones bajos en literales numéricos

Java 7+ permite usar guiones bajos en literales numéricos para mejorar su legibilidad. El compilador los ignora.

int million = 1_000_000;
long creditCard = 4_111_1111_1111_1111L;
double pi = 3.141_592_653_589_793;
int hex = 0xFF_EC_D1_2E;
int binary = 0b0001_0101_0110;

System.out.println(million);   // 1000000
System.out.println(creditCard); // 4111111111111111

BigInteger para precisión arbitraria

Cuando los valores superan el rango de long, use BigInteger. No sufre desbordamientos, pero es más lento que los tipos primitivos. Úselo para claves criptográficas, factoriales y números astronómicos.

import java.math.BigInteger;

BigInteger factorial100 = BigInteger.ONE;
for (int i = 2; i <= 100; i++) {
    factorial100 = factorial100.multiply(BigInteger.valueOf(i));
}
System.out.println(factorial100.toString().length() + " digits"); // 158 digits

BigInteger a = new BigInteger("999999999999999999999999999999");
BigInteger b = new BigInteger("1");
System.out.println(a.add(b)); // 1000000000000000000000000000000

Práctica: contador seguro frente al desbordamiento

Un patrón para implementar un contador que gestione el desbordamiento de forma segura mediante Math.addExact y recurra a Long.MAX_VALUE cuando sea necesario.

class SafeCounter {
    private long count = 0;

    public void increment() {
        try {
            count = Math.addExact(count, 1L);
        } catch (ArithmeticException e) {
            count = Long.MAX_VALUE; // cap at max
        }
    }

    public long get() { return count; }
}

SafeCounter sc = new SafeCounter();
sc.increment();
sc.increment();
System.out.println(sc.get()); // 2

Comprobación rápida

¿Cuál es el valor de la siguiente expresión?

long result = 1_000_000 * 1_000_000;
System.out.println(result);

Repaso: aritmética de enteros y desbordamiento

Conceptos clave:

El desbordamiento de enteros se produce de forma cíclica y silenciosa; de forma predeterminada no se lanza ninguna excepción
Utilice Math.addExact/multiplyExact/subtractExact para detectar desbordamientos
La división entera trunca hacia cero; el signo de % sigue al del dividendo
Utilice literales long (sufijo L) cuando los resultados intermedios puedan desbordar int
BigInteger gestiona valores de tamaño arbitrario sin desbordamientos
Los operadores de desplazamiento de bits son alternativas rápidas a la multiplicación y división por potencias de 2

Preguntas frecuentes

¿La lección «Aritmética de enteros y desbordamiento» es gratis?

Sí — el texto completo de «Aritmética de enteros y desbordamiento» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Aritmética de enteros y desbordamiento»?

Comprenda la división entera, el módulo, el comportamiento del desbordamiento y cómo detectarlo. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Aritmética de enteros y desbordamiento»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy