Abkürzung "or-assignment" (| =) Operator in Java

Question

Ich habe eine lange Reihe von Vergleichen in Java zu tun, und ich würde gerne wissen, ob einer oder mehrere von ihnen als wahr herauskommen. Die Reihe der Vergleiche war lang und schwer zu lesen, daher habe ich sie aus Gründen der Lesbarkeit getrennt und ging automatisch zur Verwendung eines Verknüpfungsoperators |= anstelle von negativeValue = negativeValue || boolean.

boolean negativeValue = false; 
negativeValue |= (defaultStock < 0); 
negativeValue |= (defaultWholesale < 0); 
negativeValue |= (defaultRetail < 0); 
negativeValue |= (defaultDelivery < 0); 

Ich erwarte, dass negativeValue um wahr zu sein, wenn eine der Standard <etwas> Werte negativ sind. Ist das gültig? Wird es tun, was ich erwarte? Ich konnte es nicht auf Suns Website oder Stackoverflow erwähnt sehen, aber Eclipse scheint kein Problem damit zu haben und der Code kompiliert und läuft.

---

Und falls ich mehrere logische Schnittstellen durchführen wollte, könnte ich verwenden &= statt &&?

Answer 1

Die |= ist ein zusammengesetzter Zuweisungsoperator (JLS 15.26.2) für den booleschen logischen Operator | (JLS 15.22.2); nicht mit dem Conditional-oder || (JLS 15.24) zu verwechseln. Es gibt auch &= und ^=, die der zusammengesetzten Zuweisungsversion der booleschen logischen & bzw. ^ entsprechen.

Mit anderen Worten, für boolean b1, b2, sind diese zwei gleichwertige:

b1 |= b2; 
b1 = b1 | b2; 

Der Unterschied zwischen den logischen Operatoren (& und |) im Vergleich zu ihren bedingten Pendants (&& und ||) ist, dass erstere nicht "Kurzschluss"; Letzteres tun. Das heißt:

• & und |immer bewerten beide Operanden
• && und || den rechten Operanden bedingt bewerten; Der rechte Operand wird nur ausgewertet, wenn sein Wert das Ergebnis der binären Operation beeinflussen könnte.Das bedeutet, dass der rechte Operand nicht ausgewertet wird, wenn:
  • Der linke Operand von &&-false wertet
    • (denn egal, was der rechte Operand ausgewertet, der gesamte Ausdruck ist false)
  • linker Operand || ausgewertet true
    • (weil kein m Atter, was der rechte Operand ausgewertet, der gesamte Ausdruck ist true)

Also auf Ihre ursprüngliche Frage zurück, ja, ist das Konstrukt gültig, und während |= ist nicht gerade eine äquivalente Abkürzung für = und || berechnet es, was Sie wollen. Da die rechte Seite des |=-Operators in Ihrer Verwendung eine einfache ganzzahlige Vergleichsoperation ist, ist die Tatsache, dass | nicht kurzschließt, unbedeutend.

Es gibt Fälle, in denen ein Kurzschluss erwünscht oder sogar erforderlich ist, aber Ihr Szenario gehört nicht dazu.

Es ist bedauerlich, dass Java im Gegensatz zu einigen anderen Sprachen nicht &&= und ||= hat. Dies wurde in der Frage Why doesn't Java have compound assignment versions of the conditional-and and conditional-or operators? (&&=, ||=) diskutiert.

Answer 2

Es ist kein "Shortcut" -Operator in der Art, dass || und & & sind (in, dass sie die RHS nicht auswerten werden, wenn sie bereits das Ergebnis basierend auf der LHS kennen), aber es wird tun, was Sie in Bezug auf arbeiten wollen.

Als Beispiel für den Unterschied, wird dieser Code in Ordnung sein, wenn text ist null:

boolean nullOrEmpty = text == null || text.equals("") 

Erwägung, dass dies nicht:

boolean nullOrEmpty = false; 
nullOrEmpty |= text == null; 
nullOrEmpty |= text.equals(""); // Throws exception if text is null 

(Offensichtlich Sie "".equals(text) für diesen bestimmte tun könnten Fall - ich versuche nur, das Prinzip zu demonstrieren.)

Answer 3

List<Integer> params = Arrays.asList (defaultStock, defaultWholesale, 
             defaultRetail, defaultDelivery); 
int minParam = Collections.min (params); 
negativeValue = minParam < 0; 

Answer 4

Sie könnten nur eine Aussage haben. mehrere Linien überexprimiert es fast genau wie Ihr Beispielcode liest, nur weniger zwingend notwendig:

boolean negativeValue 
    = defaultStock < 0 
    | defaultWholesale < 0 
    | defaultRetail < 0 
    | defaultDelivery < 0; 

Für einfachste Ausdrücke, | verwendet, kann schneller als || sein, denn auch wenn es einen Vergleich vermeidet tun es bedeutet, mit einem Zweig implizit und Das kann viel teurer sein.

Answer 5

Obwohl es für Ihr Problem vielleicht zuviel kostet, hat die Guava Bibliothek eine nette Syntax mit Predicate s und führt eine Kurzschlussauswertung von/und Predicate s durch.

Im Wesentlichen werden die Vergleiche in Objekte umgewandelt, in eine Sammlung verpackt und dann iteriert. Für oder Prädikate kehrt der erste wahre Treffer von der Iteration zurück und umgekehrt für und.

Answer 6

|| logischer Boolscher OR
| bitweise OR

| = bitweise inklusive OR und Zuweisungsoperator

Der Grund, warum | = shortcircit nicht ist, weil es eine bitweise tut oder nicht eine logische ODER-Verknüpfung. Das heißt:

 

C |= 2 is same as C = C | 2 

Tutorial for java operators

Answer 7

Wenn es um Lesbarkeit ich das Konzept der Trennung von Daten aus der Testlogik getestet haben.Codebeispiel:

// declare data 
DataType [] dataToTest = new DataType[] { 
    defaultStock, 
    defaultWholesale, 
    defaultRetail, 
    defaultDelivery 
} 

// define logic 
boolean checkIfAnyNegative(DataType [] data) { 
    boolean negativeValue = false; 
    int i = 0; 
    while (!negativeValue && i < data.length) { 
     negativeValue = data[i++] < 0; 
    } 
    return negativeValue; 
} 

Der Code sieht ausführlicher und selbsterklärend aus. Sie können sogar ein Array in Methodenaufruf wie folgt erstellen:

checkIfAnyNegative(new DataType[] { 
    defaultStock, 
    defaultWholesale, 
    defaultRetail, 
    defaultDelivery 
}); 

es besser lesbar als ‚Vergleichsstring‘ ist, und hat auch Performance-Vorteil von Kurzschlüssen (auf Kosten der Array-Zuweisung und Methodenaufruf).

Edit: Noch mehr Lesbarkeit kann einfach durch die Verwendung varargs Parameter erreicht werden: wäre

Methode Unterschrift:

boolean checkIfAnyNegative(DataType ... data) 

Und der Aufruf wie folgt aussehen könnte:

checkIfAnyNegative(defaultStock, defaultWholesale, defaultRetail, defaultDelivery);