Unterschiede in den Booleschen Operatoren: & vs && und | vs ||

Ich kenne die Regeln für &&und ||aber was sind &und |? Bitte erklären Sie mir diese anhand eines Beispiels.

Dies sind die bitweisen UND- und bitweisen ODER-Operatoren.

int a = 6; // 110
int b = 4; // 100

// Bitwise AND    

int c = a & b;
//   110
// & 100
// -----
//   100

// Bitwise OR

int d = a | b;
//   110
// | 100
// -----
//   110

System.out.println(c); // 4
System.out.println(d); // 6

Vielen Dank an Carlos für den Hinweis auf den entsprechenden Abschnitt in der Java-Sprachspezifikation ( 15.22.1 , 15.22.2 ) bezüglich der unterschiedlichen Verhaltensweisen des Operators basierend auf seinen Eingaben.

Wenn beide Eingaben boolesch sind, werden die Operatoren als boolesche logische Operatoren betrachtet und verhalten sich ähnlich wie die Operatoren Conditional-And ( &&) und Conditional-Or ( ||), mit der Ausnahme, dass sie nicht kurzschließen, solange das Folgende sicher ist ::

if((a != null) && (a.something == 3)){
}

Das ist nicht:

if((a != null) & (a.something == 3)){
}

"Kurzschluss" bedeutet, dass der Bediener nicht unbedingt alle Bedingungen untersucht. In den obigen Beispielen &&wird die zweite Bedingung nur dann untersucht, wenn dies anicht nullder Fall ist (andernfalls wird die gesamte Anweisung false zurückgeben, und es wäre ohnehin a.somethingnicht möglich, die folgenden Bedingungen zu untersuchen), sodass die Anweisung von keine Ausnahme auslöst oder als "sicher" betrachtet wird . "

Der &Operator prüft immer jede Bedingung in der Klausel, sodass in den obigen Beispielen a.somethingbewertet werden kann, ob aes sich tatsächlich um einen nullWert handelt, der eine Ausnahme auslöst.

Ich denke, Sie sprechen über die logische Bedeutung beider Operatoren. Hier haben Sie einen Tabellen-Lebenslauf:

boolean a, b;

Operation     Meaning                       Note
---------     -------                       ----
   a && b     logical AND                    short-circuiting
   a || b     logical OR                     short-circuiting
   a &  b     boolean logical AND            not short-circuiting
   a |  b     boolean logical OR             not short-circuiting
   a ^  b     boolean logical exclusive OR
  !a          logical NOT

short-circuiting        (x != 0) && (1/x > 1)   SAFE
not short-circuiting    (x != 0) &  (1/x > 1)   NOT SAFE

Kurzschlussauswertung , Minimalauswertung oder McCarthy-Auswertung (nach John McCarthy) ist die Semantik einiger Boolescher Operatoren in einigen Programmiersprachen, in denen das zweite Argument nur ausgeführt oder ausgewertet wird, wenn das erste Argument nicht ausreicht, um den Wert von zu bestimmen Ausdruck: Wenn das erste Argument der AND-Funktion false ergibt, muss der Gesamtwert false sein. und wenn das erste Argument der ODER-Funktion als wahr ausgewertet wird, muss der Gesamtwert wahr sein.

Nicht sicher bedeutet, dass der Operator immer jede Bedingung in der Klausel untersucht. In den obigen Beispielen kann 1 / x ausgewertet werden, wenn x tatsächlich ein 0-Wert ist, was eine Ausnahme auslöst.

Ich weiß, dass es hier viele Antworten gibt, aber sie scheinen alle etwas verwirrend. Nachdem ich einige Nachforschungen im Java Oracle Study Guide angestellt habe, habe ich drei verschiedene Szenarien für die Verwendung von && oder & entwickelt. Die drei Szenarien sind logisches UND , bitweises UND und boolesches UND .

Logisches UND: Das logische UND (auch als bedingtes UND bezeichnet) verwendet den Operator && . Es ist eine kurzgeschlossene Bedeutung: Wenn der linke Operand falsch ist, wird der rechte Operand nicht ausgewertet.
Beispiel:

int x = 0;
if (false && (1 == ++x) {
    System.out.println("Inside of if");
}
System.out.println(x); // "0"

Im obigen Beispiel ist der Wert, der an die Konsole von x gedruckt wird, 0, da der erste Operand in der if-Anweisung falsch ist. Daher muss Java nicht berechnen (1 == ++ x), daher wird x nicht berechnet.

Bitweises UND: Bitweises UND verwendet den Operator & . Es wird verwendet, um eine bitweise Operation für den Wert durchzuführen. Es ist viel einfacher zu sehen, was los ist, wenn man sich die Operation für Binärzahlen ansieht, z.

int a = 5;     //                    5 in binary is 0101
int b = 12;    //                   12 in binary is 1100
int c = a & b; // bitwise & preformed on a and b is 0100 which is 4

Wie Sie im Beispiel sehen können, erzeugt ein bitweises UND, das vorgeformt ist, nur eine Binärzahl, wenn dieselbe Binärdarstellung der Zahlen 5 und 12 ausgerichtet ist, wobei dieselbe Ziffer in beiden Zahlen eine 1 hat. Daher 0101 & 1100 == 0100. Was in Dezimalzahl 5 & 12 == 4 ist.

Boolesches UND: Jetzt verhält sich der boolesche UND-Operator ähnlich und unterschiedlich wie das bitweise UND und das logische UND. Ich stelle es mir gerne als ein bitweises UND zwischen zwei booleschen Werten (oder Bits) vor, daher wird es verwendet Operator & . Die booleschen Werte können auch das Ergebnis eines logischen Ausdrucks sein.

Es gibt entweder einen wahren oder einen falschen Wert zurück, ähnlich wie das logische UND, aber im Gegensatz zum logischen UND ist es nicht kurzgeschlossen. Der Grund dafür ist, dass es den Wert sowohl des linken als auch des rechten Operanden kennen muss, damit es dieses bitweise UND vorformt. Hier ist ein Ex:

int x = 0;
if (false & (1 == ++x) {
    System.out.println("Inside of if");
}
System.out.println(x); //"1"

Wenn diese if-Anweisung ausgeführt wird, wird der Ausdruck (1 == ++ x) ausgeführt, obwohl der linke Operand falsch ist. Daher ist der für x ausgedruckte Wert 1, da er inkrementiert wurde.

Dies gilt auch für logisches ODER (||), bitweises ODER (|) und boolesches ODER (|). Ich hoffe, dies beseitigt einige Verwirrung.

Die Operatoren && und || sind kurzgeschlossen, was bedeutet, dass sie ihren rechten Ausdruck nicht bewerten, wenn der Wert des linken Ausdrucks ausreicht, um das Ergebnis zu bestimmen.

& und | liefern das gleiche Ergebnis wie && und || Betreiber. Der Unterschied besteht darin, dass sie immer beide Seiten des Ausdrucks als && und || auswerten Beenden Sie die Bewertung, wenn die erste Bedingung ausreicht, um das Ergebnis zu bestimmen.

In Java sind die einzelnen Operatoren &, |, ^ ,! hängen von den Operanden ab. Wenn beide Operanden Ints sind, wird eine bitweise Operation ausgeführt. Wenn beide Boolesche Werte sind, wird eine "logische" Operation ausgeführt.

Wenn beide Operanden nicht übereinstimmen, wird ein Fehler bei der Kompilierung ausgelöst.

Die Doppeloperatoren &&, || verhalten sich ähnlich wie ihre einzelnen Gegenstücke, aber beide Operanden müssen bedingte Ausdrücke sein, zum Beispiel:

if ((a <0) && (b <0)) {...} oder ähnlich if ((a <0) || (b <0)) {...}

Quelle: Java-Programmierung lang 4th ed

&und |sind bitweise Operatoren für integrale Typen (z. B. int): http://download.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

&&und ||arbeiten nur mit Booleschen Werten (und Kurzschluss, wie andere Antworten bereits gesagt haben).

Vielleicht kann es nützlich sein zu wissen, dass die bitweisen UND- und bitweisen ODER-Operatoren immer vor dem bedingten UND und dem bedingten ODER ausgewertet werden, die im selben Ausdruck verwendet werden.

if ( (1>2) && (2>1) | true) // false!

&&; || sind logische Operatoren .... Kurzschluss

&; | sind boolesche logische Operatoren .... Nicht kurzgeschlossen

Übergang zu Unterschieden in der Ausführung von Ausdrücken. Bitweise Operatoren bewerten beide Seiten unabhängig vom Ergebnis der linken Seite. Bei der Auswertung von Ausdrücken mit logischen Operatoren hängt die Auswertung des rechten Ausdrucks jedoch von der Bedingung der linken Hand ab.

Beispielsweise:

int i = 25;
int j = 25;
if(i++ < 0 && j++ > 0)
    System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);

Dies gibt i = 26 aus; j = 25, Da die erste Bedingung falsch ist, wird die Bedingung für die rechte Hand umgangen, da das Ergebnis unabhängig von der Bedingung für die rechte Seite sowieso falsch ist. (Kurzschluss)

int i = 25;
int j = 25;
if(i++ < 0 & j++ > 0)
    System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);

Dies gibt jedoch i = 26 aus; j = 26,

Wenn ein Ausdruck mit dem Operator Boolean & ausgewertet wird, werden beide Operanden ausgewertet. Dann wird der Operator & auf den Operanden angewendet.

Wenn ein Ausdruck mit dem Operator && ausgewertet wird, wird der erste Operand ausgewertet. Wenn der erste Operand als falsch ausgewertet wird, wird die Auswertung des zweiten Operanden übersprungen.

Wenn der erste Operand den Wert true zurückgibt, wird der zweite Operand ausgewertet. Wenn der zweite Operand den Wert true zurückgibt, wird der Operator && auf den ersten und den zweiten Operanden angewendet.

Ähnliches gilt für | und ||.

Während der grundlegende Unterschied darin besteht, dass er &hauptsächlich für bitweise Operationen verwendet longwird intoder bytewo er für eine Art Maske verwendet werden kann, können die Ergebnisse unterschiedlich sein, selbst wenn Sie ihn anstelle von logisch verwenden &&.

Der Unterschied ist in einigen Szenarien deutlicher:

1. Das Auswerten einiger Ausdrücke ist zeitaufwändig
2. Die Auswertung eines Ausdrucks kann nur erfolgen, wenn der vorherige wahr ist
3. Die Ausdrücke haben einige Nebenwirkungen (beabsichtigt oder nicht)

Der erste Punkt ist recht einfach, er verursacht keine Fehler, dauert aber länger. Wenn Sie mehrere verschiedene Prüfungen in einer bedingten Anweisung haben, setzen Sie diejenigen, die entweder billiger sind oder eher scheitern, nach links.

Für den zweiten Punkt siehe dieses Beispiel:

if ((a != null) & (a.isEmpty()))

Dies schlägt fehl null, da die Auswertung des zweiten Ausdrucks a ergibt NullPointerException. Der logische Operator &&ist faul. Wenn der linke Operand falsch ist, ist das Ergebnis falsch, egal welcher rechte Operand ist.

Beispiel für den dritten Punkt - Nehmen wir an, wir haben eine App, die DB ohne Trigger oder Kaskaden verwendet. Bevor wir ein Gebäudeobjekt entfernen, müssen wir das Gebäude eines Abteilungsobjekts in ein anderes ändern. Angenommen, der Operationsstatus wird als Boolescher Wert zurückgegeben (true = success). Dann:

if (departmentDao.update(department, newBuilding) & buildingDao.remove(building))

Dies wertet beide Ausdrücke aus und führt somit das Entfernen von Gebäuden durch, selbst wenn die Abteilungsaktualisierung aus irgendeinem Grund fehlgeschlagen ist. Mit &&funktioniert es wie vorgesehen und stoppt nach dem ersten Ausfall.

Was a || bäquivalent ist !(!a && !b), es hört auf, wenn aes wahr ist , es ist keine weitere Erklärung erforderlich.