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

Traté de buscar usando Google Search y Stack Overflow, pero no apareció ningún resultado. Lo he visto en código de 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 )?

|= lee de la misma manera que += .

 notification.defaults |= Notification.DEFAULT_SOUND; 

es lo mismo que

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

donde | es el operador O bit a bit.

Todos los operadores están referenciados aquí .

Se usa un operador bit a bit porque, como es frecuente, esas constantes permiten que un int lleve marcadores.

Si miras esas constantes, verás que están en poderes 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 

Para que pueda usar el bit O para agregar banderas

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

asi que

 myFlags |= DEFAULT_LIGHTS; 

simplemente significa que agregamos una bandera.

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

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

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

Estoy escribiendo 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 Nota: (para los puntos siguientes, quería agregar mi respuesta)

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

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

  • Además ! Se llama Operador Lógico NO, pero != Comprueba si el valor de dos operandos es igual o no, si los valores no son iguales, la condición se convierte en verdadera. por ejemplo, (A != B) is true . donde como A=!B significa que B es true , A convierte en false (y si B es false , A convierte en true ).

nota al margen: | no se llama tubería, en su lugar se llama O, la tubería es la terminología de la shell transferir un proceso a la siguiente …

Es un acortamiento para esto:

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

Y | es un poco sabio O

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

En particular, cuando se aplica a una variable booleana “| =” la establecerá en VERDADERO la primera vez que encuentre una expresión verdadera en el lado derecho y mantendrá su valor VERDADERO para todas las llamadas posteriores. 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 esto útil?

Considere una situación en la que desee saber si algo ha cambiado en una variedad de objetos y, de ser así, notifique alguno de los cambios. Entonces, debería configurar un hasChanges booleano y establecerlo 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 el operador bit a bit u , y se aplica 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.