Was ist der Unterschied zwischen & und && in Java?

Ich habe immer gedacht, dass der &&Operator in Java verwendet wird, um zu überprüfen, ob beide booleschen Operanden vorhanden sind true, und der &Operator wird verwendet, um bitweise Operationen für zwei Ganzzahltypen auszuführen.

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

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

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

(x != 0) & (1/x > 1)<- dies bedeutet bewerten, (x != 0)dann bewerten und (1/x > 1)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 auswerten. (1/x > 1)Wenn Sie also x = 0 haben, ist dies absolut sicher und wird keine Ausnahme auslösen, wenn (x! = 0) als falsch ausgewertet wird, wird das Ganze direkt als falsch ausgewertet ohne die zu bewerten (1/x > 1).

BEARBEITEN:

exprA | exprB <- das heißt bewerten exprA dann bewerten und exprBdann das tun |.

exprA || exprB<- dies bedeutet bewerten exprAund nur wenn dies falsedann ausgewertet wird exprBund das tun ||.

Abgesehen davon, dass ich kein fauler Bewerter bin, indem ich beide Operanden auswerte, denke ich, dass die Hauptmerkmale von 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

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

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

Bei booleschen Argumenten bildet das einfache kaufmännische Und den (bedingungslosen) Operator "logisches UND", während das doppelte kaufmännische Und ("&&") den Operator "bedingtes logisches UND" darstellt. Das heißt, dass das einfache kaufmännische Und immer beide Argumente auswertet, während das doppelte kaufmännische Und das zweite Argument nur auswertet, wenn das erste Argument wahr ist.

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

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

Versuche dies.

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

Es ist wie im JLS (15.22.2) angegeben :

Wenn beide Operanden eines &, ^ oder | Operatoren sind vom Typ boolean oder Boolean, dann ist der Typ des bitweisen Operatorausdrucks boolean. In allen Fällen unterliegen die Operanden bei Bedarf einer 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 falsch, wenn beide Operandenwerte falsch sind. Andernfalls ist das Ergebnis wahr.

Der "Trick" ist das & es sich sowohl um einen ganzzahligen bitweisen Operator als auch um einen booleschen logischen Operator handelt . Warum also nicht, dies als Beispiel für eine Überlastung des Bedieners zu betrachten, ist vernünftig.

Ich denke, meine Antwort kann verständlicher sein:

Es gibt zwei Unterschiede zwischen &und&& .

Wenn sie als logisches UND verwenden

&und &&kann logisch sein AND, wenn das &oder&& links und rechts Ausdruck zur Folge hat alles wahr ist, die ganze Operation Ergebnis kann wahr sein.

wann &und &&wie logischAND gibt es einen Unterschied:

bei Verwendung &&als logischAND wird der rechte Ausdruck nicht ausgeführt, wenn das Ergebnis des linken Ausdrucks falsch ist.

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 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 ANDOperator verwendet werden, &&kann nicht.

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

Von der Wiki-Seite:

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

'&&': - 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, muss Condtiton2 nicht bewertet werden.

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

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

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); // Die binäre Darstellung von (12 & 6) ist 0100

Der Wert von c ist 4.

Referenz finden Sie unter http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

&&und ||werden Kurzschlussoperatoren genannt. Wenn sie verwendet werden, für ||- wenn der erste Operand ausgewertet wird true, werden die restlichen Operanden nicht ausgewertet. Für &&- wenn der erste Operand zu ausgewertet wirdfalse , werden die übrigen überhaupt nicht ausgewertet.

so if (a || (++x > 0))in diesem Beispiel die Variable x nicht erhöht bekommen , wenn eine ist true.

Bei Booleschen Werten gibt es keinen Ausgabedifferenz zwischen 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 korrigieren, 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 schreiben, (a != 0) && ( b != 0)wenn a = 0 und b = 1, geschieht Folgendes:

a != 0 -->false
expression returns false

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

Neben && und || Berücksichtigen Sie beim Kurzschließen auch den Vorrang des Bedieners, wenn Sie die beiden Formen mischen. Ich denke, es wird nicht jedem sofort klar sein, 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

& ist ein bitweiser Operator plus, der zum Überprüfen beider Bedingungen verwendet wird, da manchmal beide Bedingungen ausgewertet werden müssen. Der logische Operator && wechselt jedoch zur zweiten Bedingung, wenn die erste Bedingung true ergibt.

Alle Antworten sind great, und es scheint, dass nomehr Antworten, is needed aber ich wollte nur etwas über den &&angerufenen Operator hervorhebendependent condition

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

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

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

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

und eine andere Sache: &&und ||werden Kurzschlussauswertung genannt, weil das zweite Argument ausgeführt oder ausgewertet wird, only ifdas das firstArgument not sufficemit determinedem valuevon tutexpression

Referenzen: Java ™ Programmieranleitung (frühe Objekte), 10. Ausgabe