Operadores Aritméticos en Java

Java tiene cinco operadores aritméticos: suma, resta, multiplicación, división y resto. Su sintaxis es la misma que en C, JavaScript o Python, pero el tipado estático de Java introduce algunas sorpresas en torno a la división y el desbordamiento que conviene conocer antes de escribir cualquier cálculo.

Esta página cubre los cinco operadores, por qué la división entera trunca, cómo se comporta % con números negativos, la precedencia de operadores, los atajos ++/--, el desbordamiento entero silencioso y la trampa de la precisión en punto flotante. Para el conjunto completo de operadores de Java, consulta la descripción general de Java Operators.

Los cinco operadores

int a = 14;
int b = 4;

System.out.println(a + b);  // 18
System.out.println(a - b);  // 10
System.out.println(a * b);  // 56
System.out.println(a / b);  // 3   — integer division
System.out.println(a % b);  // 2   — remainder

La división entera trunca

Cuando ambos operandos de / son enteros, el resultado es un entero y la parte fraccionaria se descarta (se trunca hacia cero):

System.out.println(7 / 2);    // 3, not 3.5
System.out.println(-7 / 2);   // -3
System.out.println(1 / 3);    // 0

Para obtener un resultado con número real, al menos un operando debe ser de tipo punto flotante. Puedes escribir un literal como double (7.0) o convertir un int a double:

System.out.println(7.0 / 2);        // 3.5
System.out.println(7 / 2.0);        // 3.5
System.out.println((double) 7 / 2); // 3.5

La conversión tiene mayor precedencia que /, por lo que (double) 7 / 2 convierte 7 primero y luego divide, dando 3.5. Ten cuidado con (double) (7 / 2): la división entera ocurre primero y obtienes 3.0.

Esto confunde continuamente a los principiantes. Si ves 0 donde esperabas un cociente distinto de cero, sospecha de la división entera.

El operador resto %

% devuelve el resto de la división entera. Está definido de forma que (a / b) * b + (a % b) == a:

System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1  — sign matches the dividend
System.out.println(10 % -3);   // 1

Usos comunes:

• Verificar divisibilidad: if (n % 2 == 0) comprueba si es par.
• Índice circular: arr[(i + 1) % arr.length] vuelve a 0 después del último elemento.
• Extraer dígitos o unidades: n % 10 es el último dígito; seconds % 60 son los segundos dentro del minuto.

Para más utilidades numéricas — potencias, redondeo, raíces cuadradas — consulta la Java Math Class.

% también funciona con double, donde devuelve el resto IEEE 754 — útil, aunque el método Math.IEEEremainder ofrece un control más preciso.

Precedencia de operadores

Se aplican las reglas estándar:

1. *, /, % primero
2. luego +, -
3. de izquierda a derecha dentro del mismo nivel de precedencia

int result = 2 + 3 * 4;      // 14, not 20
int result2 = (2 + 3) * 4;   // 20
int result3 = 10 - 2 - 3;    // 5  — left-to-right

Ante la duda, usa paréntesis. No tiene ningún coste.

Incremento y decremento — ++ y --

Los operadores unarios ++ y -- incrementan o decrementan una variable en 1:

int x = 5;
x++;     // x is 6
x--;     // x is 5

Existen en forma prefija (++x) y postfija (x++). La diferencia importa solo dentro de una expresión:

int a = 5;
int b = a++;   // postfix: b is 5 (old value), a becomes 6
int c = ++a;   // prefix: a becomes 7, c is 7

Para mayor legibilidad, usa ++ y -- en su propia línea siempre que puedas.

El desbordamiento se produce silenciosamente

La aritmética entera con int y long da la vuelta en caso de desbordamiento — no lanza ninguna excepción:

int max = Integer.MAX_VALUE;    // 2147483647
int wrapped = max + 1;          // -2147483648 (Integer.MIN_VALUE)

Si necesitas detectar desbordamientos, usa Math.addExact, Math.multiplyExact, etc., que lanzan ArithmeticException al desbordarse.

Peculiaridades del punto flotante

double es IEEE 754 — rápido y bien soportado, pero no puede representar la mayoría de las fracciones decimales con exactitud:

System.out.println(0.1 + 0.2);   // 0.30000000000000004

Esto no es un error de Java — así funciona el punto flotante binario. Para dinero, precisión científica o cualquier situación que requiera aritmética decimal exacta, usa BigDecimal:

import java.math.BigDecimal;

BigDecimal sum = new BigDecimal("0.1").add(new BigDecimal("0.2"));
System.out.println(sum);   // 0.3

(Pasa siempre una cadena a new BigDecimal(...); new BigDecimal(0.1) seguiría recogiendo la inexactitud binaria.)

Una demostración

Qué viene a continuación

Java Assignment Operators — =, += y la familia de asignaciones compuestas.

Práctica