Cosa significa "| ="? (operatore uguale al tubo)

Ho provato a cercare usando Ricerca Google e Stack Overflow, ma non ho mostrato alcun risultato. Ho visto questo nel codice della libreria opensource:

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

Cosa significa "| =" ( pipe equal operator)?

|=legge allo stesso modo di +=.

notification.defaults |= Notification.DEFAULT_SOUND;

equivale a

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

dov'è |l'operatore OR bit-saggio.

Tutti gli operatori sono indicati qui .

Un operatore bit-saggio viene utilizzato perché, come è frequente, quelle costanti consentono a un int di trasportare flag.

Se guardi quelle costanti, vedrai che hanno poteri di due:

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

Quindi puoi usare bit-saggio O per aggiungere flag

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

così

myFlags |= DEFAULT_LIGHTS;

significa semplicemente che aggiungiamo una bandiera.

E simmetricamente, testiamo che un flag sia impostato usando &:

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

Hai già ricevuto una risposta sufficiente per la tua domanda. Ma potrebbe essere la mia risposta aiutarti di più sul |=tipo di operatori binari.

Sto scrivendo una tabella per operatori bit a bit :
sono validi i seguenti:

----------------------------------------------------------------------------------------
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  
----------------------------------------------------------------------------------------

si noti che tutti gli operatori sono operatori binari.

Nota anche : _{(per i punti seguenti ho voluto aggiungere la mia risposta)}

• >>>è un operatore bit a bit in Java che si chiama spostamento senza segno
  ma >>>=non un operatore in Java. >>> = operatore

• ~sono bit di complemento bit a bit 0 to 1 and 1 to 0(operatore unario) ma ~=non un operatore.

• Inoltre, !chiamato Logical NOT Operator, ma !=controlla se il valore di due operandi è uguale o no, se i valori non sono uguali la condizione diventa vera. es (A != B) is true. dove come A=!Bsignifica se Bè truepoi Adiventato false(e se Bè falsepoi Adiventato true).

_{nota a margine: |non si chiama pipe, invece si chiama OR, pipe è shell terminology transfer da un processo al successivo.}

Stavo cercando una risposta su cosa |=fa Groovy e sebbene le risposte sopra siano esatte, non mi hanno aiutato a capire un particolare codice che stavo guardando.

In particolare, quando applicato a una variabile booleana "| =" la imposterà su VERO la prima volta che incontra un'espressione veritiera sul lato destro e manterrà il suo valore VERO per tutte le chiamate successive = =. Come un chiavistello.

Ecco un esempio semplificato di questo:

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 

Produzione:

false
false
true
true

Modifica : perché è utile?

Considera una situazione in cui vuoi sapere se qualcosa è cambiato su una varietà di oggetti e in tal caso avvisare qualcuno delle modifiche. Quindi, dovresti impostare un valore hasChangesbooleano e impostarlo su |= diff (a,b)e quindi |= dif(b,c)ecc. Ecco un breve esempio:

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

È un accorciamento per questo:

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

Ed |è un OR un po 'saggio.

|è l' operatore bit per bit , e viene applicato come +=.

Nota: || = non esiste. (logico o) È possibile utilizzare

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

o

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