Verknüpfungsoperator "oder Zuweisung" (| =) in Java

Ich habe eine lange Reihe von Vergleichen in Java zu erledigen, und ich würde gerne wissen, ob einer oder mehrere davon als wahr herauskommen. Die Reihe der Vergleiche war lang und schwer zu lesen, daher habe ich sie aus Gründen der Lesbarkeit aufgelöst und automatisch einen Verknüpfungsoperator |=anstelle von verwendet negativeValue = negativeValue || boolean.

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

Ich erwarte negativeValue, dass dies zutrifft, wenn einer der Standardwerte für <something> negativ ist. Ist das gültig? Wird es tun, was ich erwarte? Ich konnte nicht sehen, dass es auf Suns Site oder im Stackoverflow erwähnt wurde, aber Eclipse scheint kein Problem damit zu haben und der Code wird kompiliert und ausgeführt.

Wenn ich mehrere logische Schnittpunkte ausführen wollte, könnte ich &=stattdessen anstelle von verwenden &&?

Das |=ist eine Verbindung Zuweisungsoperator ( JLS 15.26.2 ) für den Booleschen logischen Operator |( JLS 15.22.2 ); nicht zu verwechseln mit der Bedingung-oder ||( JLS 15.24 ). Darüber hinaus gibt es &=und ^=entsprechend die Verbindung Zuordnung Version der boolean logischen &und ^jeweils.

Mit anderen Worten, denn boolean b1, b2diese beiden sind äquivalent:

 b1 |= b2;
 b1 = b1 | b2;

Der Unterschied zwischen den logischen Operatoren ( &und |) im Vergleich zu ihren bedingten Gegenstücken ( &&und ||) besteht darin, dass die ersteren nicht "kurzschließen"; Letztere tun. Das ist:

• &und bewerten Sie | immer beide Operanden
• &&und ||den richtigen Operanden bedingt bewerten ; Der richtige Operand wird nur ausgewertet, wenn sein Wert das Ergebnis der Binäroperation beeinflussen könnte. Das bedeutet, dass der richtige Operand NICHT ausgewertet wird, wenn:
  • Der linke Operand von &&wertet auf ausfalse
    • (denn egal, was der richtige Operand auswertet, der gesamte Ausdruck ist false)
  • Der linke Operand von ||wertet auf austrue
    • (denn egal, was der richtige Operand auswertet, der gesamte Ausdruck ist true)

Zurück zu Ihrer ursprünglichen Frage: Ja, dieses Konstrukt ist gültig, und obwohl |=es nicht genau eine äquivalente Verknüpfung für =und ist ||, berechnet es, was Sie wollen. Da die rechte Seite des |=Operators in Ihrer Verwendung eine einfache Ganzzahlvergleichsoperation ist, ist die Tatsache, dass |kein Kurzschluss auftritt, unerheblich.

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

Es ist bedauerlich, dass Java im Gegensatz zu einigen anderen Sprachen kein &&=und hat ||=. Dies wurde in der Frage diskutiert, warum Java keine zusammengesetzten Zuweisungsversionen der Bedingungs- und und Bedingungs- oder Operatoren hat. (&& =, || =) .

Es ist kein "Shortcut" -Operator (oder Kurzschlussoperator) in der Weise, wie || und && sind (insofern werden sie die RHS nicht bewerten, wenn sie das Ergebnis basierend auf der LHS bereits kennen), aber es wird tun, was Sie in Bezug auf die Arbeit wollen .

Als Beispiel für den Unterschied ist dieser Code in Ordnung, wenn er textnull ist:

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

während dies nicht wird:

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

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

Sie könnten nur eine Aussage haben. Über mehrere Zeilen ausgedrückt, liest es sich fast genau wie Ihr Beispielcode, nur weniger wichtig:

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

Für einfachste Ausdrücke kann die Verwendung |schneller sein als ||weil, obwohl ein Vergleich vermieden wird, die implizite Verwendung einer Verzweigung bedeutet und dies um ein Vielfaches teurer sein kann.

Obwohl es für Ihr Problem übertrieben sein könnte, ist das Guava- Bibliothek eine nette Syntax mit Predicates und führt eine Kurzschlussauswertung von oder / und Predicates durch.

Im Wesentlichen werden die Vergleiche in Objekte umgewandelt, in eine Sammlung gepackt und dann wiederholt. Für oder Prädikate kehrt der erste echte Treffer aus der Iteration zurück und umgekehrt für und.

Wenn es um Lesbarkeit geht, habe ich das Konzept der Trennung von getesteten Daten aus der Testlogik. 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ärender aus. Sie können sogar ein Array im Methodenaufruf erstellen, wie folgt:

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

Es ist besser lesbar als 'Vergleichszeichenfolge' und hat auch den Leistungsvorteil des Kurzschlusses (auf Kosten der Arrayzuweisung und des Methodenaufrufs).

Bearbeiten: Noch mehr Lesbarkeit kann einfach durch Verwendung von varargs-Parametern erreicht werden:

Methodensignatur wäre:

boolean checkIfAnyNegative(DataType ... data)

Und der Anruf könnte so aussehen:

checkIfAnyNegative( defaultStock, defaultWholesale, defaultRetail, defaultDelivery );

Es ist ein alter Beitrag, aber um Anfängern eine andere Perspektive zu bieten, möchte ich ein Beispiel geben.

Ich denke, der häufigste Anwendungsfall für einen ähnlichen zusammengesetzten Operator wäre +=. Ich bin sicher, wir haben alle so etwas geschrieben:

int a = 10;   // a = 10
a += 5;   // a = 15

Was war der Sinn davon? Es ging darum, Boilerplate zu vermeiden und den sich wiederholenden Code zu eliminieren.

Die nächste Zeile macht also genau das Gleiche und vermeidet es, die Variable b1zweimal in dieselbe Zeile einzugeben.

b1 |= b2;

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

|| logisches boolesches ODER
| bitweise ODER

| = bitweises Inklusiv-ODER und Zuweisungsoperator

Der Grund, warum | = nicht kurzschließt, ist, dass es ein bitweises ODER kein logisches ODER ausführt. Das heißt:

C | = 2 ist dasselbe wie C = C | 2

Tutorial für Java-Operatoren