Operadores de Java

Los operadores son los pequeños símbolos que permiten hacer algo con los valores: sumarlos, compararlos, combinar pruebas booleanas, manipular bits o decidir entre dos expresiones. Este capítulo es una guía de todas las categorías de operadores de Java — cada categoría tiene su propio capítulo dedicado con mayor profundidad.

Las categorías

Los operadores de Java se dividen en siete grupos:

También existen instanceof (comprobación de tipo) y new (creación de objetos), que se comportan como operadores pero están vinculados a características específicas del lenguaje.

Aritméticos

Los cinco operadores aritméticos hacen lo mismo que en cualquier lenguaje, con una particularidad:

int sum     = 7 + 3;     // 10
int diff    = 7 - 3;     // 4
int product = 7 * 3;     // 21
int quotient = 7 / 3;    // 2  ← integer division truncates
int remainder = 7 % 3;   // 1

Para la división con números reales, al menos un operando debe ser double (o convertirse a uno). Consulta Java Arithmetic Operators para el tratamiento completo.

Unarios

int x = 5;
int neg = -x;       // -5
int inc = ++x;      // pre-increment: x becomes 6, inc is 6
int post = x++;     // post-increment: post is 6, then x becomes 7
boolean b = !true;  // false

++ y -- existen en formas de prefijo y postfijo. El prefijo cambia la variable y luego devuelve el nuevo valor; el postfijo devuelve el valor antiguo y luego cambia la variable. Úsalos solo en su propia línea si puedes — incrustados en expresiones son una fuente frecuente de errores.

Asignación

La asignación básica es =. Las formas compuestas combinan una operación con la asignación:

int total = 0;
total += 5;    // total = total + 5
total *= 2;    // total = total * 2
total -= 1;    // total = total - 1

Las formas compuestas también funcionan con operadores de bits (&= |= ^=) y con desplazamientos (<<= >>= >>>=). Una asignación compuesta también realiza una conversión implícita al tipo de la variable, por lo que byte b = 10; b += 5; compila aunque b + 5 sea un int — un simple b = b + 5; no compilaría. Consulta Java Assignment Operators para más detalles.

Comparación

boolean a = (5 > 3);   // true
boolean b = (5 == 5);  // true
boolean c = (5 != 5);  // false

== funciona con primitivos y referencias. En referencias comprueba la identidad del objeto (el mismo objeto en memoria), no la igualdad de contenidos. Para comparar contenidos de objetos usa .equals():

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);        // false — different objects
System.out.println(s1.equals(s2));   // true  — same contents

Esto confunde a todos la primera vez. El capítulo Java Comparison Operators explica por qué.

Lógicos

Los tres operadores lógicos combinan booleanos:

boolean a = true && false;   // false
boolean b = true || false;   // true
boolean c = !true;           // false

&& y || cortocircuitan — dejan de evaluar en cuanto se conoce el resultado. Esto es esencial cuando un lado podría lanzar una excepción:

if (list != null && list.size() > 0) { /* ... */ }  // safe — short-circuit

Como && se detiene en el primer false, list.size() nunca se llama cuando list es null, por lo que no hay NullPointerException. El capítulo Java Logical Operators cubre el cortocircuito y las formas sin cortocircuito &/| en detalle.

De bits

Para manipular bits individuales:

int and    = 0b1100 & 0b1010;   // 0b1000 = 8
int or     = 0b1100 | 0b1010;   // 0b1110 = 14
int xor    = 0b1100 ^ 0b1010;   // 0b0110 = 6
int not    = ~0;                 // -1 — all bits flipped
int left   = 1 << 4;             // 16  — shift left
int right  = 16 >> 2;            // 4   — shift right (sign-preserving)
int uright = -1 >>> 28;          // 15  — unsigned shift right

La mayoría del código Java cotidiano los usa solo para banderas, hashing y E/S de bajo nivel. Java Bitwise Operators profundiza en el tema.

Ternario

El operador ternario elige entre dos expresiones:

int x = 10;
String parity = (x % 2 == 0) ? "even" : "odd";   // "even"

Se evalúa como un valor, por lo que es más útil como el lado derecho de una asignación o dentro de una expresión más grande. Para decisiones de varios pasos, usa un if/else real para mayor legibilidad.

Precedencia de operadores

Cuando aparecen varios operadores en una expresión, Java los evalúa en un orden fijo. Las precedencias más importantes, de mayor a menor:

1. ++, --, unary -, !, ~
2. *, /, %
3. +, -
4. <<, >>, >>>
5. <, <=, >, >=, instanceof
6. ==, !=
7. & (bitwise AND)
8. ^ (bitwise XOR)
9. | (bitwise OR)
10. &&
11. ||
12. ? :
13. =, +=, -=, etc.

En caso de duda, añade paréntesis. No tienen coste en tiempo de ejecución y hacen la intención obvia al siguiente lector.

Una demostración

¿Qué sigue?

Los capítulos por categoría que siguen profundizan en cada grupo de operadores. Java Arithmetic Operators es el siguiente.

Práctica