Operatori di confronto in Java

Gli operatori di confronto prendono due operandi e producono un boolean. Java ne ha sei — uguale, diverso, e i quattro operatori relazionali. Il punto critico è che == si comporta in modo diverso con i tipi primitivi rispetto agli oggetti, ed è la fonte più comune di bug per i principianti.

I sei operatori

Ciascuno produce un boolean che puoi usare in un test if, in una condizione di ciclo, o come valore di una variabile:

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

Gli operatori relazionali (>, <, >=, <=) sono più comuni come condizioni if e controlli di ciclo:

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 i primitivi

Per i tipi primitivi, == confronta il valore:

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

Il caso floating-point è un promemoria: non confrontare valori double per uguaglianza esatta. Verifica che siano entro una piccola tolleranza:

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

== sugli oggetti — identità, non uguaglianza

Per i tipi riferimento, == confronta i riferimenti — se le due variabili puntano allo stesso oggetto in memoria. Due oggetti distinti con contenuto identico non sono ==:

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 regola pratica: per gli oggetti, usa sempre .equals() per confrontare i contenuti.

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

La forma == "quit" a volte restituisce true perché Java deduplica i letterali stringa — lo stesso letterale viene compilato nello stesso oggetto. Ma questo è un dettaglio implementativo, non una garanzia.

Objects.equals — null-safe

Se uno dei due lati potrebbe essere null, obj.equals(other) lancia una NullPointerException. Usa invece Objects.equals — gestisce null su entrambi i lati:

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

Confronto con i tipi wrapper

I tipi wrapper (Integer, Long, ecc.) seguono la regola degli oggetti — == confronta i riferimenti, non i valori:

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

(I valori da -128 a 127 sono nella cache, quindi Integer x = 100; Integer y = 100; x == y risulta essere true — ma è una particolarità della JVM, non una regola del linguaggio. Non farci affidamento.)

Confronto per ordinamento — .compareTo

<, >, <=, >= funzionano solo con i primitivi. Per confrontare oggetti in base all'ordinamento, usa il metodo Comparable.compareTo (restituisce negativo, zero, 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 e la maggior parte dei tipi "naturali" implementano Comparable. L'ordinamento personalizzato usa Comparator — trattato in Comparable e Comparator.

Una dimostrazione

Prossimi passi

Operatori logici Java — combinare espressioni boolean con &&, || e !.

Esercitati