O que significa "| ="? (operador igual de tubo)

Tentei pesquisar usando a Pesquisa do Google e o estouro de pilha, mas ele não apresentou nenhum resultado. Eu já vi isso no código da biblioteca de código-fonte aberto:

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

O que significa "| =" ( pipe equal operator)?

|=lê da mesma maneira que +=.

notification.defaults |= Notification.DEFAULT_SOUND;

é o mesmo que

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

onde |é o operador OR bit a bit.

Todos os operadores são referenciados aqui .

Um operador bit a bit é usado porque, como é frequente, essas constantes permitem que um int carregue sinalizadores.

Se você olhar para essas constantes, verá que elas têm poderes de dois:

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

Então você pode usar OR bit a bit para adicionar sinalizadores

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

tão

myFlags |= DEFAULT_LIGHTS;

simplesmente significa que adicionamos uma bandeira.

E simetricamente, testamos que um sinalizador é definido usando &:

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

Você já tem resposta suficiente para sua pergunta. Mas pode ser minha resposta ajudá-lo mais sobre o |=tipo de operadores binários.

Estou escrevendo tabela para operadores bit a bit : A
seguir, são 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 os operadores são operadores binários.

Também Nota: _{(para abaixo pontos que eu queria acrescentar a minha resposta)}

• >>>é um operador bit a bit em Java chamado deslocamento não assinado
  mas >>>=não um operador em Java. >>> = operador

• ~é bits de complemento bit a bit, 0 to 1 and 1 to 0(operador unário), mas ~=não um operador.

• Além disso, !chamado operador lógico NÃO, mas !=verifica se o valor de dois operandos é igual ou não, se os valores não são iguais, a condição se torna verdadeira. por exemplo (A != B) is true. onde como A=!Bsignifica se Bé trueentão Ase torna false(e se Bé falseentão Ase torna true).

_{nota lateral: |não é chamado pipe, em vez disso é chamado OR, pipe é terminologia de shell, transfere um processo para o próximo.}

Eu estava procurando uma resposta sobre o que |=faz no Groovy e, embora as respostas acima estejam corretas, elas não me ajudaram a entender um pedaço de código específico que eu estava procurando.

Em particular, quando aplicada a uma variável booleana "| =", ela será configurada como TRUE na primeira vez em que encontrar uma expressão verdadeira no lado direito e manterá seu valor TRUE para todas as chamadas subsequentes. Como uma trava.

Aqui está um exemplo simplificado disso:

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 

Resultado:

false
false
true
true

Edit : Por que isso é útil?

Considere uma situação em que você deseja saber se algo mudou em uma variedade de objetos e, em caso afirmativo, notifique alguma dessas alterações. Então, você configuraria um hasChangesbooleano e o definiria para |= diff (a,b)então |= dif(b,c)etc. Aqui está um breve exemplo:

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

É um encurtamento para isso:

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

E |é um pouco sábio OU.

|é o operador bit a bit - ou , e está sendo aplicado como +=.

Nota: || = não existe. (lógico ou) Você pode usar

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

ou

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