Operadores de asignación en Java

El = simple es el operador de asignación básico. Java también proporciona una familia de operadores de asignación compuestos que combinan una operación aritmética, bit a bit o de desplazamiento con la propia asignación. Ahorran unos pocos caracteres y hacen más clara la intención — "modificar esta variable en su lugar".

Asignación simple

El lado derecho se evalúa y luego se almacena en la variable del lado izquierdo:

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

Algunas reglas:

• El lado izquierdo debe ser una variable (o un elemento de array, o un campo), nunca una expresión como (x + 1) = 5.
• Los tipos deben coincidir — o el lado derecho debe ser implícitamente convertible al tipo del lado izquierdo.
• La asignación es en sí misma una expresión: int a = (b = 5); establece tanto a como b en 5.

Operadores de asignación compuestos

Cada operador aritmético y bit a bit tiene una forma de asignación compuesta asociada:

En la práctica:

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

Las formas bit a bit y de desplazamiento funcionan de la misma manera — aplican la operación sobre el valor actual de la variable y almacenan el resultado de vuelta:

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

El lado derecho se agrupa como un todo

x op= y no es una sustitución textual ciega de x = x op y. El compilador trata todo el lado derecho como un solo operando, como si estuviera entre paréntesis — 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 strings

+= también concatena en un string:

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

Cada += sobre un String crea un nuevo string internamente — los strings son inmutables. Para bucles que construyen un string largo, usa StringBuilder en su lugar (tratado en Concatenación de strings en Java).

La asignación compuesta incluye un cast implícito

Un detalle sutil pero importante: los operadores de asignación compuestos incluyen un cast implícito de vuelta al tipo de la variable. La asignación simple no lo hace.

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

Esto puede ser útil ocasionalmente — y ocasionalmente un error silencioso si oculta un desbordamiento.

La asignación es una expresión — pero no abuses de ella

Dado que la asignación produce un valor, puedes encadenarla:

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

También puedes asignar dentro de una condición if:

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

Estos modismos son comunes en bucles de E/S. Fuera de while ((x = ...) != null), prefiere sentencias separadas — son más fáciles de leer.

= vs ==

La mayor fuente de errores de un solo carácter en Java es confundir = (asignación) y == (comparación):

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

Para int y la mayoría de los tipos, el compilador detecta el error inmediatamente porque = devuelve un int, no un boolean. Con variables boolean no hay error de compilación — la asignación con = siempre devuelve el boolean asignado — así que ten especial cuidado al probar indicadores:

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 demostración

Qué sigue

Operadores de comparación en Java cubre ==, !=, los operadores relacionales y la diferencia crucial entre == y .equals() para objetos.

Práctica