¿Qué significa "| ="? (operador igual de tubería)

Intenté buscar usando Google Search y Stack Overflow, pero no mostró ningún resultado. He visto esto en el código de la biblioteca de código abierto:

Notification notification = new Notification(icon, tickerText, when);
notification.defaults |= Notification.DEFAULT_SOUND;
notification.defaults |= Notification.DEFAULT_VIBRATE;

¿Qué significa "| =" ( pipe equal operator)?

|=se lee de la misma manera que +=.

notification.defaults |= Notification.DEFAULT_SOUND;

es lo mismo que

notification.defaults = notification.defaults | Notification.DEFAULT_SOUND;

donde |está el operador OR en cuanto a bits.

Todos los operadores están referenciados aquí .

Se utiliza un operador de bit a bit porque, como es frecuente, esas constantes permiten que un int lleve banderas.

Si observas esas constantes, verás que están en potencias de dos:

public static final int DEFAULT_SOUND = 1;
public static final int DEFAULT_VIBRATE = 2; // is the same than 1<<1 or 10 in binary
public static final int DEFAULT_LIGHTS = 4; // is the same than 1<<2 or 100 in binary

Por lo tanto, puede usar OR en bits para agregar banderas

int myFlags = DEFAULT_SOUND | DEFAULT_VIBRATE; // same as 001 | 010, producing 011

entonces

myFlags |= DEFAULT_LIGHTS;

simplemente significa que agregamos una bandera.

Y simétricamente, probamos que se establezca una bandera usando &:

boolean hasVibrate = (DEFAULT_VIBRATE & myFlags) != 0;

Ya tienes suficiente respuesta para tu pregunta. Pero puede ser mi respuesta ayudarlo más sobre el |=tipo de operadores binarios.

Estoy escribiendo una tabla para operadores bit a bit : Los
siguientes son válidos:

----------------------------------------------------------------------------------------
Operator   Description                                   Example
----------------------------------------------------------------------------------------
|=        bitwise inclusive OR and assignment operator   C |= 2 is same as C = C | 2
^=        bitwise exclusive OR and assignment operator   C ^= 2 is same as C = C ^ 2
&=        Bitwise AND assignment operator                C &= 2 is same as C = C & 2
<<=       Left shift AND assignment operator             C <<= 2 is same as C = C << 2
>>=       Right shift AND assignment operator            C >>= 2 is same as C = C >> 2  
----------------------------------------------------------------------------------------

tenga en cuenta que todos los operadores son operadores binarios.

También tenga en cuenta: _{(para los puntos a continuación, quería agregar mi respuesta)}

• >>>es un operador bit a bit en Java que se llama desplazamiento sin signo
  pero >>>=no un operador en Java. >>> = operador

• ~son bits de complemento bit a bit 0 to 1 and 1 to 0(operador unario) pero ~=no un operador.

• Además, se !llama operador lógico NOT, pero !=verifica si el valor de dos operandos es igual o no, si los valores no son iguales, entonces la condición se vuelve verdadera. por ej (A != B) is true. donde como A=!Bmedios si Bse trueluego Ase convierten en false(y si Bes falseentonces Aconvertido true).

_{nota al margen: |no se llama tubería, sino que se llama OR, la tubería es la terminología de shell transfiere un proceso al siguiente ...}

Estaba buscando una respuesta sobre lo que |=hace en Groovy y, aunque las respuestas anteriores son correctas, no me ayudaron a comprender un código particular que estaba viendo.

En particular, cuando se aplica a una variable booleana "| =" lo establecerá en VERDADERO la primera vez que encuentre una expresión veraz en el lado derecho y MANTENERÁ su valor VERDADERO para todas las llamadas subsiguientes | =. Como un pestillo.

Aquí un ejemplo simplificado de esto:

groovy> boolean result  
groovy> //------------ 
groovy> println result           //<-- False by default
groovy> println result |= false 
groovy> println result |= true   //<-- set to True and latched on to it
groovy> println result |= false 

Salida:

false
false
true
true

Editar : ¿Por qué es útil?

Considere una situación en la que desea saber si algo ha cambiado en una variedad de objetos y, de ser así, notifique a alguno de los cambios. Entonces, configuraría un hasChangesbooleano y lo configurará en |= diff (a,b)y luego, |= dif(b,c)etc. Aquí hay un breve ejemplo:

groovy> boolean hasChanges, a, b, c, d 
groovy> diff = {x,y -> x!=y}  
groovy> hasChanges |= diff(a,b) 
groovy> hasChanges |= diff(b,c) 
groovy> hasChanges |= diff(true,false) 
groovy> hasChanges |= diff(c,d) 
groovy> hasChanges 

Result: true

Es un acortamiento para esto:

notification.defaults = notification.defaults | Notification.DEFAULT_SOUND;

Y |es un poco sabio OR.

|es el operador bit a bit , y se está aplicando como +=.

Nota: || = no existe. (lógico o) Puedes usar

y= y || expr; // expr is NOT evaluated if y==true

o

y = expr ? true : y;  // expr is always evaluated.