Operadores de comparación en Java

Los operadores de comparación toman dos operandos y producen un boolean. Java tiene seis de ellos: igual, diferente y los cuatro operadores relacionales. La trampa es que == hace algo distinto con primitivos que con objetos, lo cual es la fuente más común de errores en principiantes.

Los seis operadores

Cada uno produce un boolean que puedes usar en una prueba if, una condición de bucle o como valor de una variable:

int score = 85;
boolean passed = score >= 60;        // true
boolean perfect = score == 100;      // false
boolean failed = !(score >= 60);     // false

Los operadores relacionales (>, <, >=, <=) son más comunes como condiciones if y guardias de bucle:

int temperature = 30;

if (temperature > 25) {
  System.out.println("warm");        // printed
} else if (temperature < 10) {
  System.out.println("cold");
}

for (int i = 0; i < 3; i++) {        // i < 3 is the loop guard
  System.out.println(i);             // 0 1 2
}

== con primitivos

Para los tipos primitivos, == compara el valor:

int a = 5;
int b = 5;
System.out.println(a == b);    // true

double x = 0.1 + 0.2;
double y = 0.3;
System.out.println(x == y);    // false — IEEE 754 rounding

El caso de punto flotante es un recordatorio: no compares valores double por igualdad exacta. Comprueba que estén dentro de una pequeña tolerancia:

System.out.println(Math.abs(x - y) < 1e-9);   // true

== con objetos — identidad, no igualdad

Para los tipos de referencia, == compara referencias: si las dos variables apuntan al mismo objeto en memoria. Dos objetos distintos con contenido idéntico no son ==:

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

La regla general: para objetos, usa siempre .equals() para comparar contenido.

if (input.equals("quit")) { ... }      // correct
// if (input == "quit") { ... }        // works by coincidence, don't rely on it

La forma == "quit" a veces devuelve true porque Java deduplica los literales de string: el mismo literal se compila en el mismo objeto. Pero eso es un detalle de implementación, no una garantía.

Objects.equals — seguro ante null

Si cualquiera de los lados puede ser null, obj.equals(other) lanza NullPointerException. Usa Objects.equals en su lugar: maneja null en cualquiera de los lados:

import java.util.Objects;

String a = null;
String b = "hello";

System.out.println(Objects.equals(a, b));   // false (no NPE)
System.out.println(Objects.equals(a, null)); // true

Comparar objetos wrapper

Los tipos wrapper (Integer, Long, etc.) siguen la regla de objetos: == compara referencias, no valores:

Integer x = 200;
Integer y = 200;
System.out.println(x == y);         // false (usually)
System.out.println(x.equals(y));    // true

(Los valores de -128 a 127 están en caché, así que Integer x = 100; Integer y = 100; x == y resulta ser true — pero eso es una peculiaridad de la JVM, no la regla del lenguaje. No dependas de ello.)

Comparar para ordenar — .compareTo

<, >, <=, >= solo funcionan con primitivos. Para comparar objetos en cuanto al orden, usa el método Comparable.compareTo (devuelve negativo, cero o positivo):

String a = "apple";
String b = "banana";

System.out.println(a.compareTo(b));   // negative — "apple" < "banana"
System.out.println(a.compareTo(a));   // 0
System.out.println(b.compareTo(a));   // positive

Integer, Long, String, LocalDate y la mayoría de los tipos "naturales" implementan Comparable. El ordenamiento personalizado usa Comparator, que se trata en Comparable y Comparator.

Una demostración

Qué viene a continuación

Operadores lógicos en Java — combinar expresiones booleanas con &&, || y !.

Práctica