Różnice w operatorach logicznych: & vs & & I | vs ||

Myślę, że mówisz o logicznym znaczeniu obu operatorów, tutaj masz tabelę-CV:

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

Wiem, że jest tu wiele odpowiedzi, ale wszystkie wydają się nieco mylące. Tak więc po przeprowadzeniu pewnych badań z przewodnika Java Oracle study guide, wymyśliłem trzy różne scenariusze, kiedy używać & & lub&. Trzy scenariusze są logiczne i, bitowe i, oraz boolean i .

Logiczne i: Logiczne i (aka warunkowe i) wykorzystuje && centrala. To zwarcie. jeśli lewy operand jest fałszywy, to prawy operand będzie nie być oceniane.
przykład:

int x = 0;
if (false && (1 == ++x) {
    System.out.println("Inside of if");
}
System.out.println(x); // "0"

W powyższym przykładzie wartość wyświetlana na konsoli x będzie równa 0, ponieważ pierwszy argument w instrukcji if jest false, dlatego java nie musi obliczać (1 = = ++x), dlatego x nie będzie obliczany.

Bitowe oraz: Bitowe i wykorzystuje & centrala. Służy do preformowania bitowej operacji na wartości. O wiele łatwiej jest zobaczyć, co się dzieje, patrząc na operacje na liczbach binarnych ex:

int a = 5;     //                    5 in binary is 0101
int b = 12;    //                   12 in binary is 1100
int c = a & b; // bitwise & preformed on a and b is 0100 which is 4

Jako można zobaczyć w przykładzie, gdy reprezentacje binarne liczb 5 i 12 są ustawione w kolejce, a następnie bitowo i wstępnie uformowane będzie produkować tylko liczbę binarną, gdzie ta sama cyfra w obu liczbach ma 1. Stąd 0101 & 1100 = = 0100. Co w dziesiętnym to 5 & 12 == 4.

Boolean AND: Teraz operator boolean and zachowuje się podobnie i inaczej zarówno do bitowego i jak i logicznego i. Lubię myśleć o tym jako o preformowaniu bitowym i między dwiema wartościami logicznymi (lub bitami), dlatego używa & centrala. Wartości logiczne mogą być również wynikiem wyrażenia logicznego.

Zwraca wartość true lub false, podobnie jak logiczne AND, ale w przeciwieństwie do logicznego i nie jest zwarta. Powodem jest to, że aby preformował to bitowo i, musi znać wartość zarówno lewego, jak i prawego operanda. Oto ex:

int x = 0;
if (false & (1 == ++x) {
    System.out.println("Inside of if");
}
System.out.println(x); //"1"

Teraz, gdy polecenie if zostanie uruchomione, zostanie wykonane wyrażenie (1 == ++x), nawet jeśli lewe operand jest fałszywy. Stąd wartość wydrukowana dla x będzie równa 1, ponieważ została zwiększona.

Dotyczy to również logicznego OR ( | |), bitowego OR ( / ) I boolean OR ( / ) Mam nadzieję, że to rozwiąże pewne zamieszanie.

Operatory & & i / / są zwarte, co oznacza, że nie będą oceniać swojego wyrażenia po prawej stronie, jeśli wartość wyrażenia po lewej jest wystarczająca do określenia wyniku.

& i | zapewniają taki sam wynik jak operatory & & i|/. Różnica polega na tym, że zawsze oceniają obie strony wyrażenia, gdzie jako && i || przestają oceniać, czy pierwszy warunek wystarczy do ustalenia wyniku.

W Javie pojedyncze operatory&,/,^,! zależy od operandów. Jeśli oba operandy są intami, to wykonywana jest operacja bitowa. Jeśli oba są wartościami logicznymi, wykonywana jest operacja "logiczna".

Jeśli oba operandy są niedopasowane, wyświetlany jest błąd czasu kompilacji.

Operatory podwójne&&, | | zachowują się podobnie jak ich pojedyncze odpowiedniki, ale oba operandy muszą być wyrażeniami warunkowymi, na przykład:

If (( a

Źródło: java programming Lang 4th ed

& i | są operatorami bitowymi na typach całkowych (np. int): http://download.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

&& i || działają tylko na booleanach(i zwarciach, jak już mówiły inne odpowiedzi).

Być może warto wiedzieć, że operatory bitowe AND I bitwise OR są zawsze obliczane przed warunkowymi i i warunkowymi lub używane w tym samym wyrażeniu.

if ( (1>2) && (2>1) | true) // false!

&& ; || są operatorami logicznymi.... zwarcie

&; / są operatorami logicznymi typu boolean.... Brak zwarcia

Przejście do różnic w wykonywaniu wyrażeń. Operatory bitowe oceniają obie strony niezależnie od wyniku lewej strony. Jednak w przypadku ewaluacji wyrażeń za pomocą operatorów logicznych, ewaluacja wyrażenia prawej ręki jest zależna od warunku lewej ręki.

Na Przykład:

int i = 25;
int j = 25;
if(i++ < 0 && j++ > 0)
    System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);

To wyświetli i=26; j=25, jako pierwszy warunek jest false the right hand condition is omińed as the result is false anyway niezależnie od the right hand side condition.(zwarcie)

int i = 25;
int j = 25;
if(i++ < 0 & j++ > 0)
    System.out.println("OK");
System.out.printf("i = %d ; j = %d",i,j);

Ale to wydrukuje i=26; j=26,

Jeśli wyrażenie zawierające Boolean & operator jest oceniany, oba operandy są oceniane. Następnie operator & jest stosowany do operandu.

Gdy wyrażenie z udziałem && operator jest oceniany, pierwszy operand jest oceniany. Jeśli pierwszy parametr zostanie oceniony na false, to wartość drugiego parametru zostanie pominięta.

Jeśli pierwszy operand Zwraca wartość true, to drugi operand jest obliczany. Jeśli drugi operand zwróci wartość true wtedy operator & & jest następnie stosowany do pierwszego i drugiego operandu.

Podobne do / i//.

Podczas gdy podstawowa różnica polega na tym, że & jest używany do operacji bitowych głównie na long, int lub byte gdzie może być używany do rodzaju maski, wyniki mogą się różnić, nawet jeśli używasz go zamiast logicznego &&.

Różnica jest bardziej zauważalna w niektórych scenariuszach:

1. ocena niektórych wyrażeń jest czasochłonna
2. ocena jednego z wyrażeń może być wykonana tylko wtedy, gdy poprzednie było prawdziwe
3. wyrażenia mają kilka efekt uboczny (zamierzony lub nie)

Pierwszy punkt jest dość prosty, nie powoduje błędów, ale zajmuje więcej czasu. Jeśli w jednej instrukcji warunkowej znajduje się kilka różnych sprawdzeń, umieść w lewo te, które są tańsze lub bardziej prawdopodobne, że się nie powiedzą.

Po drugie, zobacz ten przykład:

if ((a != null) & (a.isEmpty()))

Nie powiodło się to dla null, ponieważ ocena drugiego wyrażenia daje NullPointerException. Operator logiczny && jest leniwy, jeśli lewy operand jest false, wynik jest false no ważne, jaki jest właściwy operand.

Przykład dla trzeciego punktu-powiedzmy, że mamy aplikację, która używa DB bez żadnych wyzwalaczy lub kaskad. Zanim usuniemy obiekt budowlany, musimy zmienić budynek obiektu Wydziałowego na inny. Załóżmy również, że status operacji jest zwracany jako wartość logiczna (true = success). Następnie:

if (departmentDao.update(department, newBuilding) & buildingDao.remove(building))

To ocenia oba wyrażenia i tym samym wykonuje usuwanie budynku, nawet jeśli aktualizacja działu nie powiodła się z jakiegoś powodu. Z &&, działa jak zamierzony i zatrzymuje się po pierwszej awarii.

Jeśli chodzi o a || b, jest to odpowiednik !(!a && !b), zatrzymuje się, jeśli a jest prawdą, nie potrzeba więcej wyjaśnień.