it-swarm.com.de

Unterschied zwischen & und &&

Ich habe immer gedacht, dass der &&-Operator in Java verwendet wird, um zu überprüfen, ob die beiden booleschen Operanden true sind, und der &-Operator wird für bitweise Operationen an zwei Integer-Typen verwendet.

Kürzlich habe ich erfahren, dass der &-Operator auch verwendet werden kann, um zu überprüfen, ob seine beiden booleschen Operanden true sind. Der einzige Unterschied besteht darin, dass er den RHS-Operanden überprüft, selbst wenn der LHS-Operand falsch ist.

Ist der &-Operator in Java intern überlastet? Oder steckt dahinter ein anderes Konzept? 

132
Lavneesh

& <- überprüft beide Operanden
&& <- stoppt die Auswertung, wenn der erste Operand falsch ist, da das Ergebnis falsch ist

(x != 0) & (1/x > 1) <- das bedeutet, (x != 0) auswerten, dann (1/x > 1) auswerten und dann das & ausführen. Das Problem ist, dass für x = 0 eine Ausnahme ausgelöst wird.

(x != 0) && (1/x > 1) <- Dies bedeutet auswerten (x != 0) und nur wenn dies wahr ist, dann (1/x > 1) auswerten. Wenn Sie also x = 0 haben, ist dies absolut sicher und es wird keine Ausnahme ausgelöst, wenn (x! = 0) das Ganze direkt als falsch bewertet wertet "false" aus, ohne den (1/x > 1) auszuwerten.

BEARBEITEN:

exprA | exprB <- Dies bedeutet, exprA auszuwerten, dann exprB auszuwerten und dann den | auszuführen.

exprA || exprB <- Dies bedeutet, exprA auszuwerten. Nur wenn dies false ist, dann exprB auswerten und den || ausführen.

231
ITroubs

Abgesehen davon, dass ich nicht als Lazy-Evaluator tätig bin, indem ich beide Operanden auswerte, sind die Hauptmerkmale von bitweisen Operatoren im Vergleich zu den einzelnen Bytes der Operanden wie im folgenden Beispiel dargestellt:

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
42
suat
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
29
Torres

Das hängt von der Art der Argumente ab ...

Bei ganzzahligen Argumenten ist das einzige Et-Zeichen ("&") der Operator "bitweises AND". Das doppelte Et-Zeichen ("&&") ist nur für zwei boolesche Argumente definiert.

Bei booleschen Argumenten bildet das einfache kaufmännische Und den (unbedingten) "logischen AND" -Operator, während das doppelte kaufmännische Und ("&&") der "bedingte logische AND" -Operator ist. Dies bedeutet, dass das einfache Et-Zeichen immer beide Argumente auswertet, während das doppelte Et-Zeichen das zweite Argument nur dann auswertet, wenn das erste Argument wahr ist.

Bei allen anderen Argumenttypen und Kombinationen sollte ein Fehler bei der Kompilierung auftreten.

10
developer

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

Versuche dies.

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

Ich denke, meine Antwort kann verständlicher sein:

Es gibt zwei Unterschiede zwischen & und &&.

Wenn sie als logisches AND verwendet werden

& und && können logisch AND sein. Wenn der linke und rechte Ausdruck des & oder && Ausdrucks alle wahr ist, kann das gesamte Operationsergebnis wahr sein.

bei & und && als logische AND gibt es einen Unterschied:

wenn && als logische AND verwendet wird und 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 

}

Noch ein weiteres 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, && kann nicht.

Der bitweise AND-Operator "&" erzeugt genau dann 1, wenn beide Bits in Seine Operanden sind 1. Wenn jedoch beide Bits 0 sind oder beide Bits unterschiedlich sind, erzeugt dieser Operator 0. Um genauer zu sein, gibt der AND-Operator "&" den Wert 1 zurück, wenn eines der beiden Bits 1 ist, und gibt zurück 0, wenn eines der Bits 0 ist.

Von der Wiki-Seite:

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

7
aircraft

es ist wie in JLS (15.22.2) } angegeben

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

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

Für ^ ist der Ergebniswert true, wenn sich die Operandenwerte unterscheiden. Andernfalls ist das Ergebnis falsch.

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

Der "Trick" ist, dass & ein Integer-Bitweise-Operator sowie ein Boolean-Logischer Operator ist. Warum also nicht, dies als ein Beispiel für das Überladen von operator zu betrachten, ist vernünftig.

5
Andreas_D

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

Zum Beispiel: - Bedingung1 && Bedingung2

Wenn Bedingung1 falsch ist, ist (Bedingung1 && Bedingung2) immer falsch. Dies ist der Grund, warum dieser logische Operator auch als Kurzschlussoperator bezeichnet wird, da er keine andere Bedingung auswertet. Wenn Bedingung1 falsch ist, besteht keine Notwendigkeit, Condtiton2 zu bewerten.

Wenn Bedingung1 wahr ist, wird Bedingung2 ausgewertet. Wenn sie wahr ist, ist das Gesamtergebnis wahr, ansonsten ist es falsch.

"&": - ist ein bitweiser AND-Operator. Es erzeugt eine Eins (1) in der Ausgabe, wenn beide Eingangsbits Eins sind. Andernfalls wird Null (0) erzeugt.

Zum Beispiel:-

int a = 12; // Binärdarstellung von 12 ist 1100

int b = 6; // Binärdarstellung von 6 ist 0110

int c = (a & b); // Binärdarstellung von (12 & 6) ist 0100

Der Wert von c ist 4.

weitere Informationen finden Sie hier http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

4
satish

Bei Booleans gibt es keinen Leistungsunterschied zwischen den beiden. Sie können && und & oder || tauschen und | und es wird niemals das Ergebnis Ihres 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 eingeben, 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 ist, geschieht Folgendes:

a != 0 -->false
expression returns false

Weniger Schritte, weniger Verarbeitung, bessere Codierung, besonders wenn viele boolesche Ausdrücke oder komplizierte Argumente verwendet werden.

3
Ryan

&& und || werden Kurzschlussoperatoren genannt. Wenn sie für || verwendet werden - wenn der erste Operand als true ausgewertet wird, werden die übrigen Operanden nicht ausgewertet. Für && - wenn der erste Operand als false ausgewertet wird, werden die übrigen nicht bewertet.

if (a || (++x > 0)) In diesem Beispiel wird die Variable x nicht inkrementiert, wenn atrue war.

3
ACV

Neben && und || Da es sich um einen Kurzschluss handelt, sollten Sie beim Kombinieren der beiden Formen auch den Vorrang des Bedieners berücksichtigen. Ich denke, es wird nicht für jeden sofort ersichtlich, dass result1 und result2 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
3
mgr326639

& ist ein bitweiser Operator, der zur Überprüfung beider Bedingungen verwendet wird, da manchmal beide Bedingungen ausgewertet werden müssen.

alle Antworten sind great, und es scheint, dass no mehr Antwort is needed, aber ich wollte nur etwas auf den &&-Operator mit dem Namen dependent condition hinweisen.

In Ausdrücken, die den Operator && verwenden, kann eine Bedingung - wir nennen dies den dependent condition - erfordern, dass eine andere Bedingung wahr ist, damit die Auswertung der abhängigen Bedingung sinnvoll ist. 

In diesem Fall sollte die abhängige Bedingung hinter dem Operator && stehen, um Fehler zu vermeiden.

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

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

und noch etwas: && und || heißen Kurzschlussbewertung weil das zweite Argument ausgeführt oder ausgewertet wird only if das first-Argument not suffice auf determine die value der expression

Referenzen: Java ™ - Programmieren (frühe Objekte), zehnte Ausgabe

0