¿Qué significa "| ="? (Operador de tubo igual)

He intentado buscar utilizando la Búsqueda de Google y el Desbordamiento de pila, pero no mostró ningún resultado. He visto esto en el código de la biblioteca opensource:

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

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

    6 Solutions collect form web for “¿Qué significa "| ="? (Operador de tubo igual)”

    |= 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 OR bit-wise.

    Aquí se hace referencia a todos los operadores.

    Un operador bit-wise se utiliza porque, como es frecuente, esas constantes permiten a un int llevar banderas.

    Si nos fijamos en esas constantes, veremos que están en potencia 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 

    Así que puede utilizar bit-wise 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 una bandera se establece usando & :

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

    Usted ya tiene suficiente respuesta para su pregunta. Pero puede ser que mi respuesta le ayude más sobre |= clase de operadores binarios.

    Estoy escribiendo mesa 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 ---------------------------------------------------------------------------------------- 

    Note que todos los operadores son operadores binarios.

    También Nota: (para los puntos abajo quería añadir mi respuesta)

    • >>> es un operador bit a bit en Java que se llama Desplazamiento sin signo
      Pero >>>= no es un operador en Java. Operador

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

    • Además ! Llamado Operador NOT lógico, pero != Comprueba si el valor de dos operandos son iguales o no, si los valores no son iguales entonces la condición se convierte en verdadera. Por ejemplo (A != B) is true . Donde como A=!B significa que si B es true entonces A convierte en false (y si B es false entonces A convierte en true ).

    Nota lateral: | No se llama la pipa, en lugar de su OR llamada, la pipa es terminología de la cáscara transfiere un proceso hacia fuera a la siguiente.

    Es un acortamiento para esto:

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

    Y | Es un bit-wise OR.

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

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

    En particular, cuando se aplica a una variable booleana "| =" se establecerá en TRUE la primera vez que encuentre una expresión verídica en el lado derecho y mantendrá su valor TRUE 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 útil?

    Considere una situación en la que desea saber si algo ha cambiado en una variedad de objetos y, en caso afirmativo, notifique alguno de los cambios. Por lo tanto, se podrí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 

    Nota: || = no existe. (Lógico o) Puede utilizar

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

    o

     y = expr ? true : y; // expr is always evaluated. 
    FlipAndroid es un fan de Google para Android, Todo sobre Android Phones, Android Wear, Android Dev y Aplicaciones para Android Aplicaciones.