Operadores en Java: aritméticos, de comparación, lógicos y de asignación

Qué hacen los operadores

Los operadores son los símbolos que combinan valores para calcular otros nuevos. Ya los usas de forma intuitiva (+ suma, > compara) y Java los agrupa en unas pocas familias: aritméticos, de comparación, lógicos, de asignación, y un par de especiales como el incremento y el ternario.

La mayoría de los operadores toman dos valores (uno antes y otro después del símbolo) y producen un resultado. La clave está en saber de qué tipo es ese resultado y en qué orden se aplican, que es donde tropiezan los principiantes.

Operadores aritméticos

Los cinco operadores aritméticos trabajan con números: +, -, *, / y % (resto).

public class Main {
    public static void main(String[] args) {
        int a = 17;
        int b = 5;

        System.out.println(a + b);   // 22
        System.out.println(a - b);   // 12
        System.out.println(a * b);   // 85
        System.out.println(a / b);   // 3  (¡división entera!)
        System.out.println(a % b);   // 2  (el resto)
    }
}

El operador % es el resto tras la división: 17 % 5 es 2 porque 5 cabe en 17 tres veces y sobran 2. Es la herramienta de cada día para comprobar la divisibilidad: n % 2 == 0 es la comprobación estándar de "¿es n par?".

Ten en cuenta también que + cumple una doble función: con números suma, pero con un String a cualquiera de los lados une texto.

public class Main {
    public static void main(String[] args) {
        System.out.println("Total: " + 3 + 4);   // Total: 34
        System.out.println("Total: " + (3 + 4));  // Total: 7
    }
}

La primera línea se lee de izquierda a derecha: "Total: " + 3 ya es una cadena, así que el 4 se añade como texto. Envuelve la operación entre paréntesis cuando quieras que se calcule primero.

El truco de la división entera

Esta es la sorpresa más habitual de todas. Cuando ambos operandos de / son enteros, Java hace una división entera y descarta la fracción: no redondea, trunca hacia cero.

public class Main {
    public static void main(String[] args) {
        System.out.println(5 / 2);        // 2, no 2.5
        System.out.println(9 / 10);       // 0
        System.out.println(5.0 / 2);      // 2.5  (con un double basta)
        System.out.println((double) 5 / 2); // 2.5 (cast a un operando)
    }
}

Para obtener un resultado decimal, haz que al menos un operando sea un double: o lo escribes con un .0, o haces un cast de un lado con (double). Hacer (double)(5 / 2) no ayuda, porque la división entera 5 / 2 ya ocurrió antes del cast; debes hacer el cast a un operando, no al resultado.

Operadores de comparación

Los operadores de comparación plantean una pregunta de sí/no y devuelven un boolean. Hay seis: ==, !=, <, >, <=, >=.

public class Main {
    public static void main(String[] args) {
        int score = 75;

        System.out.println(score >= 60);   // true
        System.out.println(score == 100);  // false
        System.out.println(score != 0);    // true
    }
}

Fíjate en la diferencia entre = (asignación: "pon este valor aquí") y == (comparación: "¿son iguales?"). Confundirlos es un error clásico.

Una advertencia importante: == compara referencias de objetos, no contenidos. Para las cadenas, usa .equals().

public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");

        System.out.println(a == b);        // false - objetos distintos
        System.out.println(a.equals(b));   // true  - mismo texto
    }
}

Usa == para primitivos como int y boolean, y .equals() siempre que compares el contenido de objetos como String.

Operadores lógicos

Los operadores lógicos combinan valores booleanos: && (y), || (o) y ! (no). Son la forma de expresar condiciones como "es lo bastante mayor y tiene una entrada".

public class Main {
    public static void main(String[] args) {
        int age = 20;
        boolean hasTicket = true;

        System.out.println(age >= 18 && hasTicket);  // true
        System.out.println(age < 13 || hasTicket);    // true
        System.out.println(!hasTicket);                // false
    }
}

&& y || aplican evaluación de cortocircuito: Java deja de evaluar en cuanto la respuesta es segura. Con &&, si el lado izquierdo es false el derecho no se comprueba nunca; con ||, si el lado izquierdo es true el derecho se omite. Esto no es solo una optimización: puedes apoyarte en ello por seguridad:

if (text != null && text.length() > 0) { ... }

Si text es null, el lado izquierdo es false y text.length() no se llama nunca, evitando una NullPointerException. Invierte el orden y reventaría.

Asignación e incremento

= asigna, pero Java también tiene asignaciones compuestas que combinan una operación con la asignación: +=, -=, *=, /=, %=. Y ++ / -- suman o restan uno.

public class Main {
    public static void main(String[] args) {
        int count = 10;

        count += 5;   // count = count + 5  -> 15
        count -= 2;   // -> 13
        count *= 2;   // -> 26
        System.out.println(count);

        count++;      // -> 27
        count--;      // -> 26
        System.out.println(count);
    }
}

++ viene en dos variantes: postfijo (count++) devuelve el valor antiguo y luego incrementa; prefijo (++count) incrementa primero y luego devuelve el nuevo valor. La diferencia solo importa cuando usas el resultado en la misma expresión:

public class Main {
    public static void main(String[] args) {
        int x = 5;
        System.out.println(x++);   // imprime 5, luego x pasa a 6
        System.out.println(++x);   // x pasa a 7, imprime 7
    }
}

Cuando ++ está en su propia línea, postfijo o prefijo da igual; así que usa el que se lea con claridad y no metas incrementos dentro de expresiones más grandes.

El operador ternario

El ternario condition ? a : b es un if/else compacto que produce un valor: si la condición es true se evalúa a a, en caso contrario a b.

public class Main {
    public static void main(String[] args) {
        int score = 72;

        String result = score >= 60 ? "pass" : "fail";
        System.out.println(result);   // pass

        int max = (score > 100) ? 100 : score;
        System.out.println(max);      // 72
    }
}

Brilla en asignaciones cortas de tipo uno-u-otro. Resiste la tentación de anidar ternarios dentro de ternarios: eso se vuelve ilegible enseguida, y un if/else normal es más claro.

Precedencia y paréntesis

Los operadores se aplican en un orden fijo, muy parecido al de las matemáticas: *, /, % se ligan más fuerte que + y -, que se ligan más fuerte que las comparaciones, que se ligan más fuerte que &&, y luego ||.

public class Main {
    public static void main(String[] args) {
        System.out.println(2 + 3 * 4);        // 14, no 20
        System.out.println((2 + 3) * 4);      // 20
        System.out.println(5 > 3 && 1 < 2);   // true
    }
}

No necesitas memorizar la tabla completa. Cuando una expresión mezcla familias o tienes que pararte a deducir el orden, añade paréntesis: no cuestan nada y dejan la intención clara para quien lo lea después.

Siguiente: conversión de tipos

Varios de los trucos de aquí -la división entera, mezclar int y double- se reducen a los tipos. Convertir entre tipos numéricos de forma deliberada se llama casting, y de eso trata la página siguiente.