Was bedeutet "| ="? (Pipe Equal Operator)

Ich habe versucht, mit der Google-Suche und dem Stapelüberlauf zu suchen, aber es wurden keine Ergebnisse angezeigt. Ich habe dies im OpenSource-Bibliothekscode gesehen:

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

Was bedeutet "| =" ( pipe equal operator)?

|=liest sich genauso wie +=.

notification.defaults |= Notification.DEFAULT_SOUND;

ist das gleiche wie

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

Wo |ist der bitweise ODER-Operator?

Alle Operatoren werden hier referenziert .

Ein bitweiser Operator wird verwendet, da diese Konstanten, wie häufig, es einem int ermöglichen, Flags zu tragen.

Wenn Sie sich diese Konstanten ansehen , werden Sie feststellen, dass sie Zweierpotenzen haben:

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

Sie können also bitweises ODER verwenden, um Flags hinzuzufügen

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

so

myFlags |= DEFAULT_LIGHTS;

bedeutet einfach, dass wir eine Flagge hinzufügen.

Und symmetrisch testen wir, ob ein Flag gesetzt ist mit &:

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

Sie haben bereits eine ausreichende Antwort auf Ihre Frage. Aber vielleicht hilft Ihnen meine Antwort mehr über die |=Art der binären Operatoren.

Ich schreibe eine Tabelle für bitweise Operatoren :
Folgendes ist gültig:

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

Beachten Sie, dass alle Operatoren binäre Operatoren sind.

Auch Anmerkung: _{(für unten Punkte Ich wollte meine Antwort hinzufügen)}

• >>>ist ein bitweiser Operator in Java, der als vorzeichenlose Verschiebung bezeichnet wird
  aber >>>=kein Operator in Java. >>> = Operator

• ~ist bitweise Komplementbits 0 to 1 and 1 to 0(unärer Operator), aber ~=kein Operator.

• Zusätzlich als !logischer NICHT-Operator bezeichnet, !=prüft jedoch, ob der Wert von zwei Operanden gleich ist oder nicht. Wenn die Werte nicht gleich sind, wird die Bedingung wahr. zB (A != B) is true. wobei als A=!BMittel , wenn Bist , truedann Awerden false(und wenn Bist , falsedann Awerden true).

_{Randnotiz: |heißt nicht Pipe, sondern heißt OR, Pipe ist Shell-Terminologie. Übertragen Sie einen Prozess zum nächsten.}

Ich suchte nach einer Antwort auf das, was |=in Groovy funktioniert, und obwohl die obigen Antworten richtig sind, haben sie mir nicht geholfen, einen bestimmten Code zu verstehen, den ich mir angesehen habe.

Insbesondere wenn es auf eine boolesche Variable angewendet wird, setzt "| =" sie auf TRUE, wenn sie zum ersten Mal auf einen wahrheitsgemäßen Ausdruck auf der rechten Seite trifft, und hält ihren TRUE-Wert für alle nachfolgenden Aufrufe | =. Wie ein Riegel.

Hier ein vereinfachtes Beispiel dafür:

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 

Ausgabe:

false
false
true
true

Edit : Warum ist das nützlich?

Stellen Sie sich eine Situation vor, in der Sie wissen möchten, ob sich an einer Vielzahl von Objekten etwas geändert hat, und benachrichtigen Sie in diesem Fall eine der Änderungen. Sie würden also einen hasChangesBooleschen Wert einrichten und ihn auf |= diff (a,b)und dann |= dif(b,c)usw. setzen. Hier ein kurzes Beispiel:

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 ist eine Verkürzung dafür:

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

Und |ist ein bisschen weise ODER.

|ist der bitweise-oder- Operator und wird wie angewendet +=.

Hinweis: || = existiert nicht. (logisch oder) Sie können verwenden

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

oder

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