Różnica między & i &&

Poza tym, że nie jestem leniwym ewaluatorem oceniającym oba operandy, myślę, że główne cechy operatorów bitowych porównują każdy bajt operandów, jak w poniższym przykładzie:

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

To zależy od rodzaju argumentów...

Dla argumentów całkowitych, pojedynczy ampersand ("&")jest operatorem "bit-wise AND". Podwójny ampersand ("&&") nie jest zdefiniowany dla niczego oprócz dwóch argumentów logicznych.

Dla argumentów logicznych, pojedynczy ampersand stanowi (bezwarunkowy) operator "logiczny i", podczas gdy podwójny ampersand ( "& & " ) jest operatorem "warunkowym logicznym i". Oznacza to, że pojedynczy ampersand zawsze ocenia oba argumenty, podczas gdy double ampersand oceni drugi argument tylko wtedy, gdy pierwszy argument jest prawdziwy.

Dla wszystkich innych typów argumentów i kombinacji, powinien wystąpić błąd w czasie kompilacji.

&& jest operatorem zwarcia, podczas gdy & jest operatorem i.

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

Myślę, że moja odpowiedź może być bardziej zrozumiała:

Istnieją dwie różnice między & i &&.

Jeśli używają jako logiczne i

& i && może być logiczne AND, gdy wynik & lub && wynik lewego i prawego wyrażenia jest prawdziwy, cały wynik operacji może być prawdziwy.

Gdy & i && jako logiczne AND, Istnieje różnica:

Gdy użyjesz && jako logicznego AND, jeśli wynik lewego wyrażenia jest false, właściwe wyrażenie nie zostanie wykonane.

Weźmy przykład:

String str = null;

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

}

If using &:

String str = null;

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

}

Inny przykład:

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
}

& może być używany jako operator bitowy

& może być używany jako operator bitowy AND, && nie może.

Operator bitowy i " &" tworzy 1 wtedy i tylko wtedy, gdy oba bity w jego operandami są 1. Jeśli jednak oba bity są równe 0 lub oba bity są różne, to operator produkuje 0. Aby być bardziej precyzyjnym bitowym i operator " &" zwraca 1, Jeśli którykolwiek z dwóch bitów wynosi 1 i zwraca 0, jeśli którykolwiek z bitów wynosi 0. 

Ze strony wiki:

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

Jest jak określono w JLS (15.22.2):

Jeśli oba operandy operatora&, ^ lub | są typu boolean lub Boolean, to typ wyrażenia operatora bitowego jest boolean. We wszystkich przypadkach operandy podlegają konwersji unboxingu (§5.1.8) w razie potrzeby.

Dla&, wartość wyniku jest true, jeśli obie wartości są prawdziwe; w przeciwnym razie wynik jest false.

Dla^, wartość wyniku jest true, jeśli wartości operandu są różne; w przeciwnym razie wynik jest fałszywy.

Dla|, wartość wyniku jest false, jeśli obie wartości są false; w przeciwnym razie wynik jest true.

Sztuczka polega na tym, że & jest operatorem bitowym , a także operatorem logicznym . Więc dlaczego nie, postrzeganie tego jako przykład przeciążenia operatora jest rozsądne.

'&&' : - jest logicznym, a operator wytwarza wartość logiczną true lub false opartą na logicznej relacji jego argumentów.

Na przykład: - Condition1 & & Condition2

Jeśli warunek 1 jest false, to (warunek 1 && warunek 2) zawsze będzie false, to jest powód, dla którego ten operator logiczny jest również znany jako operator zwarcia, ponieważ nie ocenia innego warunku. Jeśli warunek 1 jest false, to nie ma potrzeby oceniania warunku 2.

Jeśli Warunek 1 jest prawdziwy, wtedy warunek 2 jest oceniany, jeśli jest prawdziwy, to ogólny wynik będzie prawdziwy, w przeciwnym razie będzie fałszywy.

'&' : - jest bitowym i operatorem. Generuje jeden (1) na wyjściu, jeśli oba bity wejściowe są jednością. W przeciwnym razie daje zero (0).

Na przykład:-

Int a=12; / / binarna reprezentacja 12 to 1100

Int b = 6; / / binarna reprezentacja 6 to 0110

Int c = (A & b); / / binarna reprezentacja (12 & 6) wynosi 0100

The wartość c wynosi 4.

W celach informacyjnych, zapoznaj się z tym http://techno-terminal.blogspot.in/2015/11/difference-between-operator-and-operator.html

&& i || nazywane są operatorami zwarciowymi. Gdy są używane, for || - jeśli pierwszy operand zostanie oceniony na true, to reszta operandów nie będzie oceniana. For && - jeśli pierwszy parametr zostanie oceniony na false, reszta nie zostanie w ogóle oceniona.

Więc if (a || (++x > 0)) w tym przykładzie zmienna x nie zostanie zwiększona, jeśli A jest true.

W przypadku wartości logicznych nie ma różnicy między tymi dwoma wyjściami. Możesz zamienić & & i & lub | / I / i to nigdy nie zmieni wyniku Twojego wyrażenia.

Różnica leży za sceną, gdzie informacje są przetwarzane. Kiedy poprawi się wyrażenie " (a != 0) & (b != 0) " dla a = 0 i b = 1 następuje:

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

Kiedy piszesz wyrażenie (a != 0) && ( b != 0) Gdy a = 0 i b = 1, następuje:

a != 0 -->false
expression returns false

Mniej kroków, mniej przetwarzania, lepiej kodowanie, szczególnie podczas wykonywania wielu wyrażeń boolowskich lub skomplikowanych argumentów.

Poza tym, że & & i || są zwarciami, należy również wziąć pod uwagę pierwszeństwo operatora podczas mieszania obu form. Myślę, że nie będzie od razu oczywiste dla wszystkich, że result1 i result2 zawierają różne wartości.

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

& jest operatorem bitowym plus używanym do sprawdzania obu warunków, ponieważ czasami musimy ocenić oba warunki. Ale operator & & logiczny przechodzi do drugiego warunku, gdy pierwszy warunek daje true.

Wszystkie odpowiedzi są great i wydaje się, że no Więcej odpowiedzi is needed ale po prostu chciałem zwrócić uwagę na coś o && operatorze o nazwie dependent condition

W wyrażeniach używających operatora &&, warunek-nazwijmy to dependent condition - może wymagać, aby inny warunek był prawdziwy, aby ocena warunku zależnego była znacząca.

W tym przypadku warunek zależny powinien być umieszczony po operatorze&&, aby zapobiec błędom.

Rozważmy wyrażenie (i != 0) && (10 / i == 2). Na warunek zależny (10 / i == 2) musi appear after operator &&, aby zapobiec możliwości dzielenia przez zero.

Kolejny przykład (myObject != null) && (myObject.getValue() == somevaluse)

I jeszcze jedno: && i || nazywa się zwarcie oceny ponieważ drugi argument jest wykonywany lub oceniany only if argument first robi not suffice determine value z expression

Referencje: Java™ How To Program (Early Objects), Tenth Edition