Unterschied zwischen & und &&

Ich dachte immer, dass && operator in Java verwendet wird, um zu überprüfen, ob beide booleschen Operanden true , und der Operator & wird verwendet, um bitweise Operationen an zwei Integer-Typen auszuführen.

Kürzlich habe ich erfahren, dass & operator auch verwendet werden kann, um zu überprüfen, ob beide booleschen Operanden true , der einzige Unterschied besteht darin, dass der RHS-Operand geprüft wird, selbst wenn der LHS-Operand falsch ist.

Ist der Operator & in Java intern überladen? Oder gibt es ein anderes Konzept dahinter?

& < - überprüft beide Operanden
&& < - hört auf auszuwerten, wenn der erste Operand falsch ist, da das Ergebnis falsch ist

(x != 0) & (1/x > 1) < - das heißt, evaluate (x != 0) dann auswerten (1/x > 1) dann das & tun. Das Problem ist, dass für x = 0 eine Ausnahme ausgetriggers wird.

(x != 0) && (1/x > 1) < - das heißt, evaluate (x != 0) und nur wenn das wahr ist, dann werte (1/x > 1) , wenn du also x = 0 hast ist vollkommen sicher und wird keine Ausnahme casting, wenn (x! = 0) zu falsch auswertet, das ganze Ding wird direkt zu falsch ausgewertet, ohne die (1/x > 1) zu bewerten.

BEARBEITEN:

exprA | exprB exprA | exprB < - das bedeutet, evaluiere exprA evaluiere dann exprA und exprB dann das | .

exprA || exprB exprA || exprB < - dies bedeutet, dass exprA ausgewertet exprA und nur wenn dies false ist, evaluiere exprB und mache das || .

Abgesehen davon, dass ich durch Auswertung beider Operanden kein träger Evaluator bin, denke ich, dass die Hauptmerkmale der bitweisen Operatoren jedes Byte von Operanden wie im folgenden Beispiel vergleichen:

 int a = 4; int b = 7; System.out.println(a & b); // prints 4 //meaning in an 32 bit system // 00000000 00000000 00000000 00000100 // 00000000 00000000 00000000 00000111 // =================================== // 00000000 00000000 00000000 00000100 
 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 

Es hängt von der Art der Argumente ab …

Bei ganzzahligen Argumenten ist das einzelne Ampersand (“&”) der “bitweise UND” -Operator. Das doppelte kaufmännische Und (“&&”) ist nur für zwei boolesche Argumente definiert.

Für boolesche Argumente bildet das einzelne Et-Zeichen den (unbedingten) “logischen AND” -Operator, während das doppelte Ampersand (“&&”) der “bedingte logische UND-Operator” ist. Das heißt, dass das einzelne kaufmännische Und immer beide Argumente auswertet, während das doppelte kaufmännische Und nur das zweite Argument auswertet, wenn das erste Argument wahr ist.

Für alle anderen Argumenttypen und Kombinationen sollte ein Kompilierungserrors auftreten.

&& ist ein Kurzschlussoperator, während & ist ein AND-Operator.

Versuche dies.

  String s = null; boolean b = false & s.isEmpty(); // NullPointerException boolean sb = false && s.isEmpty(); // sb is false 

Ich denke, meine Antwort kann verständlicher sein:

Es gibt zwei Unterschiede zwischen & und && .

Wenn sie als logisches UND verwenden

& und && kann logisch AND , wenn das Ergebnis von & oder && linker und rechter Ausdruck wahr ist, kann das Ergebnis der gesamten Operation wahr sein.

wenn & und && als logisches AND , gibt es einen Unterschied:

Wenn && als logisches AND , wenn das Ergebnis des linken Ausdrucks falsch ist, wird der rechte Ausdruck nicht ausgeführt.

Nehmen Sie das Beispiel:

 String str = null; if(str!=null && !str.equals("")){ // the right expression will not execute } 

Bei Verwendung von & :

 String str = null; if(str!=null & !str.equals("")){ // the right expression will execute, and throw the NullPointerException } 

Ein anderes Beispiel:

 int x = 0; int y = 2; if(x==0 & ++y>2){ System.out.print(“y=”+y); // print is: y=3 } 

 int x = 0; int y = 2; if(x==0 && ++y>2){ System.out.print(“y=”+y); // print is: y=2 } 

& kann als Bitoperator verwendet werden

& kann als Bitweiser AND Operator verwendet werden, && nicht.

Der bitweise AND “&” Operator erzeugt 1, wenn und nur wenn beide Bits in seinen Operanden 1 sind. Wenn jedoch beide Bits 0 sind oder beide Bits verschieden sind, dann erzeugt dieser Operator 0. Genauer gesagt bitweise UND “&” -Operator gibt 1 zurück, wenn eines der beiden Bits 1 ist, und es gibt 0 zurück, wenn eines der Bits 0 ist.

Von der Wiki-Seite:

http://www.roseindia.net/java/master-java/java-bitwise-and.shtml

es ist wie in der JLS (15.22.2) angegeben :

Wenn beide Operanden eines &, ^ oder | Operator ist vom Typ boolean oder Boolean, dann ist der Typ des bitweisen Operatorausdrucks boolesch. In allen Fällen unterliegen die Operanden der Unboxing-Konvertierung (§5.1.8).

Für & ist der Ergebniswert wahr, wenn beide Operandenwerte wahr sind; Andernfalls ist das Ergebnis falsch.

Für ^ ist der Ergebniswert wahr, wenn die Operandenwerte unterschiedlich sind; Andernfalls ist das Ergebnis falsch.

Für | ist der Ergebniswert false, wenn beide Operandenwerte falsch sind; Ansonsten ist das Ergebnis wahr.

Der “Trick” ist, dass & ist ein Integer Bitweiser Operator sowie ein Boolean Logical Operator . Warum also nicht, dies als Beispiel für eine Überlastung des Bedieners zu sehen, ist vernünftig.

‘&&’: – ist ein logischer AND-Operator, der basierend auf der logischen Beziehung seiner Argumente einen booleschen Wert von true oder false erzeugt.

Zum Beispiel: – Condition1 && Condition2

Wenn Bedingung1 falsch ist, ist (Bedingung1 && Bedingung2) immer falsch, das ist der Grund, warum dieser logische Operator auch als Kurzschlussoperator bekannt ist, weil er keine andere Bedingung auswertet. Wenn Bedingung1 falsch ist, muss Condtiton2 nicht ausgewertet werden.

Wenn Bedingung1 wahr ist, dann wird Bedingung2 ausgewertet, wenn sie wahr ist, dann wird das Gesamtergebnis wahr sein, sonst wird es falsch sein.

‘&’: – ist ein bitweiser UND-Operator. Es erzeugt eine Eins (1) im Ausgang, wenn beide Eingangsbits eins sind. Andernfalls erzeugt es Null (0).

Beispielsweise:-

int a = 12; // binäre Darstellung von 12 ist 1100

int b = 6; // binäre Darstellung von 6 ist 0110

int c = (a & b); // binäre Darstellung von (12 & 6) ist 0100

Der Wert von c ist 4.

Als Referenz siehe http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

&& und || werden Kurzschlussoperatoren genannt. Wenn sie benutzt werden, für || – Wenn der erste Operand true ergibt, werden die restlichen Operanden nicht ausgewertet. Für && – wenn der erste Operand zu false ausgewertet wird, werden die restlichen überhaupt nicht ausgewertet.

if (a || (++x > 0)) in diesem Beispiel die Variable x nicht inkrementiert wird, wenn a true .

Bei booleschen Werten gibt es keinen Unterschied zwischen den beiden Ausgaben. Sie können && und & oder || austauschen und | und es wird niemals das Ergebnis deines Ausdrucks ändern.

Der Unterschied liegt hinter der Szene, in der die Informationen verarbeitet werden. Wenn Sie einen Ausdruck “(a! = 0) & (b! = 0)” für a = 0 und b = 1 richtig setzen, geschieht Folgendes:

 left side: a != 0 --> false right side: b 1= 0 --> true left side and right side are both true? --> false expression returns false 

Wenn Sie einen Ausdruck (a != 0) && ( b != 0) schreiben, wenn a = 0 und b = 1, passiert Folgendes:

 a != 0 -->false expression returns false 

Weniger Schritte, weniger Verarbeitung, bessere Codierung, besonders bei vielen booleschen Ausdrücken oder komplizierten Argumenten.

Neben && und || Kurzschlüsse, berücksichtigen Sie auch Operator Vorrang beim Mischen der beiden Formen. Ich denke, dass es für jeden nicht sofort offensichtlich sein wird, dass Ergebnis1 und Ergebnis2 unterschiedliche Werte enthalten.

 boolean a = true; boolean b = false; boolean c = false; boolean result1 = a || b && c; //is true; evaluated as a || (b && c) boolean result2 = a | b && c; //is false; evaluated as (a | b) && c 

& ist ein bitweiser Operator plus, mit dem beide Bedingungen überprüft werden, da wir manchmal beide Bedingungen auswerten müssen. Aber && logischer Operator geht in die zweite Bedingung, wenn die erste Bedingung wahr ist.

Alle Antworten sind great , und es scheint, dass no Antwort mehr is needed aber ich wollte einfach etwas über && operator genannt dependent condition &&

In Ausdrücken, die den Operator && verwenden, kann eine Bedingung – wir nennen dies die dependent condition – eine andere Bedingung erforderlich machen, damit die Bewertung der abhängigen Bedingung aussagekräftig ist.

In diesem Fall sollte die abhängige Bedingung nach dem Operator && platziert werden, um Fehler zu vermeiden.

Betrachte den Ausdruck (i != 0) && (10 / i == 2) . Die abhängige Bedingung (10 / i == 2) muss appear after dem Operator && appear after , um die Möglichkeit der Division durch Null zu verhindern.

ein anderes Beispiel (myObject != null) && (myObject.getValue() == somevaluse)

und noch etwas: && und || werden als Kurzschlussauswertung bezeichnet, da das zweite Argument only if ausgeführt oder ausgewertet wird only if das first Argument not suffice , determine den value des expression zu determine

Referenzen: Java ™ How To Program (frühe Objekte), zehnte Ausgabe