Operadores de Comparação em Java

Os operadores de comparação recebem dois operandos e produzem um boolean. Java possui seis deles — igual, diferente e os quatro operadores relacionais. O detalhe é que == funciona de forma diferente em primitivos e em objetos, o que é a fonte mais comum de bugs para iniciantes.

Os seis operadores

Cada um produz um boolean que pode ser usado em um teste if, numa condição de laço ou como valor de uma variável:

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

Os operadores relacionais (>, <, >=, <=) são mais comuns como condições de if e guardas de laços:

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
}

== em primitivos

Para tipos primitivos, == compara o 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

O caso de ponto flutuante é um lembrete: não compare valores double com igualdade exata. Verifique se estão dentro de uma pequena tolerância:

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

== em objetos — identidade, não igualdade

Para tipos de referência, == compara referências — se as duas variáveis apontam para o mesmo objeto na memória. Dois objetos distintos com conteúdo idêntico não são ==:

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

A regra geral: para objetos, sempre use .equals() para comparar conteúdos.

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

A forma == "quit" às vezes retorna true porque Java elimina duplicatas de literais string — o mesmo literal compila para o mesmo objeto. Mas isso é um detalhe de implementação, não uma garantia.

Objects.equals — null-safe

Se qualquer um dos lados puder ser null, obj.equals(other) lança NullPointerException. Use Objects.equals — ele lida com null em qualquer lado:

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

Comparando objetos wrapper

Tipos wrapper (Integer, Long, etc.) seguem a regra de objetos — == compara referências, não valores:

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

(Valores de -128 a 127 são armazenados em cache, então Integer x = 100; Integer y = 100; x == y tende a ser true — mas isso é uma peculiaridade da JVM, não uma regra da linguagem. Não dependa disso.)

Comparando para ordenação — .compareTo

<, >, <=, >= funcionam apenas em primitivos. Para comparar objetos quanto à ordenação, use o método Comparable.compareTo (retorna negativo, zero ou 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 e a maioria dos tipos "naturais" implementam Comparable. Ordenação personalizada usa Comparator — abordado em Comparable e Comparator.

Uma demonstração

O que vem a seguir

Operadores Lógicos em Java — combinando expressões booleanas com &&, || e !.

Prática