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

Question

Ich habe immer gedacht, dass && Operator in Java wird verwendet, um zu überprüfen, ob seine beiden booleschen Operanden true und die & Operator wird verwendet, um Bit-weise Operationen auf zwei Integer-Typen durchzuführen.

Vor kurzem habe ich erfahren, dass & Operator kann auch verwendet werden, um zu überprüfen, ob seine beiden booleschen Operanden true Der einzige Unterschied besteht darin, dass der RHS-Operand auch dann geprüft wird, wenn der LHS-Operand falsch ist.

Ist die & Operator in Java intern überladen? Oder steckt da ein anderes Konzept dahinter?

Answer 1

& <-- prüft beide Operanden
&& <-- bricht die Auswertung ab, wenn der erste Operand als falsch bewertet wird, da das Ergebnis falsch ist

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

(x != 0) && (1/x > 1) <-- das bedeutet auswerten (x != 0) und nur wenn dies der Fall ist, bewerten Sie (1/x > 1) Wenn Sie also x=0 haben, dann ist das vollkommen sicher und wird keine Ausnahme auslösen, wenn (x != 0) zu false ausgewertet wird, dann wird das Ganze direkt zu false ausgewertet, ohne die (1/x > 1) .

EDITAR:

exprA | exprB <-- das bedeutet auswerten exprA dann auswerten exprB dann die | .

exprA || exprB <-- das bedeutet auswerten exprA und nur dann, wenn es sich um false dann auswerten exprB und machen die || .

Answer 2

Abgesehen davon, dass es sich nicht um einen faulen Auswerter handelt, der beide Operanden auswertet, denke ich, dass die Hauptmerkmale der bitweisen Operatoren jedes Byte der 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

Answer 3

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

Answer 4

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

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

Bei booleschen Argumenten stellt das einfache kaufmännische Und den (unbedingten) "logischen UND"-Operator dar, während das doppelte kaufmännische Und ("&&") der "bedingte logische UND"-Operator ist. Das bedeutet, 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 Kompilierfehler auftreten.

Answer 5

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

Versuchen Sie dies.

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