Operatori Java

Gli operatori sono i piccoli simboli che permettono di fare qualcosa con i valori: sommarli, confrontarli, combinare test booleani, impostare bit, scegliere tra due espressioni. Questo capitolo è una mappa di tutte le categorie di operatori Java — ogni categoria ha il proprio capitolo dedicato che approfondisce l'argomento.

Le categorie

Gli operatori Java si dividono in sette gruppi:

Esistono anche instanceof (verifica del tipo) e new (creazione di oggetti) che si comportano come operatori, ma sono legati a specifiche funzionalità del linguaggio.

Aritmetici

I cinque operatori aritmetici fanno quello che fanno in qualsiasi linguaggio, con una particolarità:

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

Per la divisione con numeri reali, almeno un operando deve essere double (o eseguire un cast a double). Consulta Operatori Aritmetici Java per la trattazione completa.

Unari

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

++ e -- esistono nelle forme prefissa e postfissa. La forma prefissa modifica la variabile e poi restituisce il nuovo valore; la forma postfissa restituisce il vecchio valore e poi modifica la variabile. Usali possibilmente solo su una riga separata — se incorporati in espressioni sono una frequente fonte di bug.

Assegnazione

L'assegnazione di base è =. Le forme composte combinano un'operazione con l'assegnazione:

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

Le forme composte funzionano anche con gli operatori bitwise (&= |= ^=) e con gli shift (<<= >>= >>>=). Un'assegnazione composta esegue anche un cast implicito al tipo della variabile, quindi byte b = 10; b += 5; compila anche se b + 5 è un int — un semplice b = b + 5; non lo farebbe. Consulta Operatori di Assegnazione Java per i dettagli.

Confronto

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

== funziona su primitivi e riferimenti. Sui riferimenti verifica l'identità dell'oggetto (stesso oggetto in memoria), non l'uguaglianza del contenuto. Per confrontare il contenuto degli oggetti 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

Questo mette in difficoltà tutti la prima volta. Il capitolo Operatori di Confronto Java spiega perché.

Logici

I tre operatori logici combinano booleani:

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

&& e || eseguono il corto circuito — smettono di valutare non appena il risultato è noto. Questo è fondamentale quando un lato potrebbe lanciare un'eccezione:

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

Poiché && si ferma al primo false, list.size() non viene mai chiamato quando list è null, quindi non si verifica alcuna NullPointerException. Il capitolo Operatori Logici Java tratta il corto circuito e le forme non a corto circuito &/| in modo completo.

Bitwise

Per manipolare i singoli bit:

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 maggior parte del codice Java quotidiano utilizza questi operatori solo per flag, hashing e I/O di basso livello. Operatori Bitwise Java approfondisce l'argomento.

Ternario

L'operatore ternario sceglie tra due espressioni:

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

Viene valutato come un valore, quindi è più utile come parte destra di un'assegnazione o all'interno di un'espressione più grande. Per decisioni a più passaggi, usa un if/else vero e proprio per leggibilità.

Precedenza degli operatori

Quando in un'espressione compaiono più operatori, Java li valuta in un ordine fisso. Le precedenze più importanti, dalla più alta alla più bassa:

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

In caso di dubbio, aggiungi le parentesi. Non costano nulla a runtime e rendono l'intenzione ovvia al prossimo lettore.

Una dimostrazione

Cosa c'è dopo

I capitoli successivi per categoria approfondiscono ogni gruppo di operatori. Operatori Aritmetici Java è il prossimo.

Pratica