Operatori di assegnazione in Java

Il singolo = è l'operatore di assegnazione di base. Java fornisce anche una famiglia di operatori di assegnazione composti che combinano un'operazione aritmetica, bitwise o di shift con l'assegnazione stessa. Risparmiano qualche carattere e rendono l'intento — "modifica questa variabile in-place" — più chiaro.

Assegnazione semplice

Il lato destro viene valutato e poi memorizzato nella variabile a sinistra:

int x = 5;
int y = x + 3;
y = y * 2;
System.out.println(y);   // 16

Alcune regole:

• Il lato sinistro deve essere una variabile (o un elemento di array, o un campo), mai un'espressione come (x + 1) = 5.
• I tipi devono corrispondere — oppure il lato destro deve essere implicitamente convertibile nel tipo del lato sinistro.
• L'assegnazione è essa stessa un'espressione: int a = (b = 5); imposta sia a che b a 5.

Operatori di assegnazione composti

Ogni operatore aritmetico e bitwise ha una forma di assegnazione composta associata:

In pratica:

int total = 0;
total += 5;    // total = 5
total += 3;    // total = 8
total *= 2;    // total = 16
total -= 1;    // total = 15
total /= 3;    // total = 5

Le forme bitwise e di shift funzionano nello stesso modo — applicano l'operazione al valore corrente della variabile e memorizzano il risultato:

int flags = 0b0101;   // 5
flags |= 0b0010;      // set a bit  -> 0b0111 = 7
flags &= 0b0110;      // clear bits -> 0b0110 = 6
flags <<= 1;          // shift left -> 0b1100 = 12

Il lato destro viene raggruppato come un insieme

x op= y non è una sostituzione testuale cieca di x = x op y. Il compilatore tratta l'intero lato destro come un unico operando, come se fosse tra parentesi — x = x op (y):

int x = 10;
x *= 2 + 3;   // x = x * (2 + 3) = 50, NOT x = x * 2 + 3 = 23
System.out.println(x);   // 50

+= con le stringhe

+= concatena anche sulle stringhe:

String greeting = "Hello";
greeting += ", world!";   // "Hello, world!"

Ogni += su una String crea una nuova stringa internamente — le stringhe sono immutabili. Per i cicli che costruiscono una stringa lunga, usa StringBuilder (trattato in Java String Concatenation).

L'assegnazione composta include un cast implicito

Una sottigliezza importante: gli operatori di assegnazione composti includono un cast implicito al tipo della variabile. L'assegnazione semplice non lo fa.

byte b = 10;
// b = b + 1;       // compile error: int can't fit into byte without a cast
b += 1;             // OK — compound form casts implicitly
System.out.println(b);   // 11

Questo è talvolta utile — e talvolta un errore silenzioso se nasconde un overflow.

L'assegnazione è un'espressione — ma non abusarne

Poiché l'assegnazione produce un valore, è possibile concatenarla:

int a, b, c;
a = b = c = 10;     // all three set to 10

È anche possibile assegnare all'interno di un test if:

String line;
while ((line = reader.readLine()) != null) {
    process(line);
}

Questi idiomi sono comuni nei cicli di I/O. Al di fuori di while ((x = ...) != null), preferisci istruzioni separate — sono più facili da leggere.

= vs ==

La principale fonte di bug da un solo carattere in Java è confondere = (assegnazione) e == (confronto):

int x = 5;
// if (x = 10) { ... }   // compile error: int is not a boolean
// if (x == 10) { ... }  // OK

Per int e la maggior parte dei tipi, il compilatore rileva immediatamente l'errore perché = restituisce un int, non un boolean. Con le variabili boolean non c'è errore di compilazione — l'assegnazione con = restituisce sempre il boolean assegnato — quindi fai particolare attenzione quando verifichi i flag:

boolean isOpen = false;
if (isOpen = true) { ... }   // bug: this sets isOpen and is always true
if (isOpen == true) { ... }  // works, but...
if (isOpen) { ... }          // ...this is what you actually want

Una dimostrazione

Cosa viene dopo

Java Comparison Operators tratta ==, !=, gli operatori relazionali e la differenza cruciale tra == e .equals() per gli oggetti.

Esercitazione