В чем разница между & и && в Java? - PullRequest
145 голосов
/ 06 апреля 2011

Я всегда думал, что оператор && в Java используется для проверки того, являются ли оба его булевых операнда true, а оператор & используется для побитовых операций над двумя целочисленными типами.

Недавно я узнал, что оператор & также может использоваться для проверки того, являются ли оба его булевых операнда true, с той лишь разницей, что он проверяет операнд RHS, даже если операнд LHS имеет значение false.

Оператор & в Java перегружен?Или за этим стоит какая-то другая концепция?

Ответы [ 13 ]

243 голосов
/ 06 апреля 2011

& <- проверяет оба операнда <br>&& <- прекращает оценку, если первый операнд оценивается как ложное, поскольку результат будет ложным </p>

(x != 0) & (1/x > 1) <- это означает оценку <code>(x != 0)затем оцените (1/x > 1), затем выполните &.проблема в том, что для x = 0 это вызовет исключение.

(x != 0) && (1/x > 1) <- это означает оценку <code>(x != 0) и только если это правда, тогда оцените (1/x > 1), так что если у вас есть x = 0тогда это совершенно безопасно и не выдает никаких исключений, если (x! = 0) оценивается как ложное, все это напрямую оценивается как ложное без оценки (1/x > 1).

РЕДАКТИРОВАТЬ:

exprA | exprB <- это означает оценку <code>exprA, затем оценку exprB, затем |.

exprA || exprB <- это означает оценку <code>exprA, и только если это falseзатем оцените exprB и выполните ||.

46 голосов
/ 26 августа 2011

Помимо того, что я не ленивый оценщик, оценивая оба операнда, я думаю, что основные характеристики побитовых операторов сравнивают каждый байт операндов, как в следующем примере:

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
29 голосов
/ 06 апреля 2011
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
10 голосов
/ 06 апреля 2011

Это зависит от типа аргументов ...

Для целочисленных аргументов один амперсанд ("&") является оператором "побитового И".Двойной амперсанд ("&&") не определен ни для чего, кроме двух логических аргументов.

Для логических аргументов одиночный амперсанд составляет (безусловный) оператор "логического И", тогда как двойной амперсанд ("&&")является условным логическим оператором ИТо есть, один амперсанд всегда оценивает оба аргумента, тогда как двойной амперсанд будет оценивать второй аргумент только в том случае, если первый аргумент истинен.

Для всех других типов и комбинаций аргументов должна возникать ошибка времени компиляции.

9 голосов
/ 06 апреля 2011

&& является оператором короткого замыкания, а & является оператором AND.

Попробуйте это.

    String s = null;
    boolean b = false & s.isEmpty(); // NullPointerException
    boolean sb = false && s.isEmpty(); // sb is false
7 голосов
/ 11 апреля 2017

Я думаю, что мой ответ может быть более понятным:

Есть два различия между & и &&.

Если они используют как логическое И

& и && могут быть логическими AND, когда результат левого и правого выражений & или && все равен true, весь результат операции может быть истинным.

когда & и && в качестве логического AND, есть разница:

при использовании && в качестве логического AND, если результатом левого выражения является ложь, правое выражение не будетвыполнить.

Взять пример:

String str = null;

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

}

При использовании &:

String str = null;

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

}

Еще один пример:

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
}

& может использоваться как битовый оператор

& может использоваться как битовый оператор AND, && не может.

Оператор побитового И "&" выдает 1 в том и только в том случае, если оба бита в его операндах равны 1. Однако, если оба бита равны 0 или оба бита различны, этот оператор prвыводит 0. Чтобы быть более точным, побитовое И оператор «&» возвращает 1, если любой из двух битов равен 1, и возвращает 0, если любой из битов равен 0.

Со страницы вики:

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

5 голосов
/ 06 апреля 2011

как указано в JLS (15.22.2) :

Когда оба операнда a, ^ или | оператор имеет тип логический или логический, тогда тип выражения побитового оператора - логический. Во всех случаях, операнды могут быть преобразованы без распаковки (§5.1.8) по мере необходимости.

Для & значение результата равно true, если оба значения операнда имеют значение true; в противном случае результат будет ложным.

Для ^ значение результата равно true, если значения операндов различны; в противном случае результат будет ложным.

Для | значение результата равно false, если оба значения операнда имеют значение false; в противном случае результат верен.

«Уловка» заключается в том, что & является целочисленным побитовым оператором , а также логическим логическим оператором . Так почему бы и нет, рассмотрим это как пример для перегрузки операторов разумно.

4 голосов
/ 17 ноября 2015

'&&': - оператор логического И создает логическое значение true или false на основе логической взаимосвязи его аргументов.

Например: - Condition1 && Condition2

ЕслиУсловие1 ложно, тогда (Условие1 && Условие2) всегда будет ложью, поэтому этот логический оператор также известен как Оператор короткого замыкания, поскольку он не оценивает другое условие.Если Condition1 имеет значение false, тогда нет необходимости оценивать Condtiton2.

Если Condition1 имеет значение true, тогда Condition2 оценивается, если оно истинно, тогда общий результат будет истинным, иначе он будет ложным.

'&': - является побитовым оператором AND.Он выдает единицу (1) на выходе, если оба входных бита равны единице.В противном случае выдает ноль (0).

Например: -

int a = 12;// двоичное представление 12 равно 1100

int b = 6;// двоичное представление 6: 0110

int c = (a & b);// двоичное представление (12 и 6) - 0100

Значение c равно 4.

для справки, см. этот http://techno -terminal.blogspot.in / 2015/11/difference-between-operator-and-operator.html

3 голосов
/ 26 сентября 2017

Кроме && и || будучи коротким замыканием, также учитывайте приоритет оператора при смешивании двух форм. Я думаю, что не всем сразу будет понятно, что result1 и result2 содержат разные значения.

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 голосов
/ 29 апреля 2016

&& и || называются операторами короткого замыкания. Когда они используются, для || - если первый операнд оценивается как true, то остальные операнды не оцениваются. Для && - если первый операнд оценивается как false, остальные из них вообще не оцениваются.

поэтому if (a || (++x > 0)) в этом примере переменная x не будет увеличиваться, если a было true.

...