Разница между & и &&

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

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

Является ли оператор & в Java внутренне перегружен? Или есть какая-то другая концепция?

& <- проверяет оба операнда
&& <- останавливает оценку, если первый операнд оценивает значение false, поскольку результат будет ложным

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

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

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

exprA | exprB exprA | exprB <- это означает, что exprA вычисляет exprB затем выполняет | ,

exprA || exprB exprA || exprB <- это означает вычисление exprA и только если это false тогда оцените exprB и сделайте || ,

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

 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 

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

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

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

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

&& – оператор короткого замыкания, а & – оператор И.

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

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

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

Существуют две отличия между & и && .

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

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

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

когда use && как логическое 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 , && не может.

Побитовый оператор AND & lt; & производит 1 тогда и только тогда, когда оба бита в его операндах равны 1. Однако, если оба бита равны 0 или оба бита отличаются друг от друга, то этот оператор производит 0. Точнее поразрядное И оператор & & возвращает 1, если какой-либо из двух битов равен 1, и он возвращает 0, если любой из бит равен 0.

На странице вики:

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

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

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

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

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

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

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

‘&&’: – является логическим оператором AND, производящим логическое значение true или false, основанное на логической связи его аргументов.

Например: – Условие1 && Условие2

Если Condition1 является ложным, то условие (Condition1 && Condition2) всегда будет ложным, поэтому этот логический оператор также известен как Short Circuit Operator, потому что он не оценивает другое условие. Если Condition1 является ложным, то нет необходимости оценивать Condtiton2.

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

‘&’: – является Поразрядным И Оператором. Он выводит один (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

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

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

С булевыми выходами между ними нет никакой разницы. Вы можете поменять && и & или || и | и он никогда не изменит результат вашего выражения.

Разница лежит за сценой, где обрабатывается информация. Когда вы правы выражения “(a! = 0) & (b! = 0)” для a = 0 и b = 1, происходит следующее:

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

Когда вы пишете выражение (a != 0) && ( b != 0) когда a = 0 и b = 1, происходит следующее:

 a != 0 -->false expression returns false 

Меньше шагов, меньше обработки, лучшего кодирования, особенно при выполнении множества логических выражений или сложных аргументов.

Кроме того, && и || будучи коротким замыканием, также учитывайте приоритет оператора при смешивании двух форм. Я думаю, что сразу не будет очевидно, что результат1 и 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 

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

все ответы great , и кажется, что больше ответа is needed но я только что выиграл, чтобы указать что-то о && operator, называемом dependent condition

В выражениях с использованием оператора && условие – мы будем называть это dependent condition – для этого нужно другое условие, чтобы быть истинным для оценки зависимого условия, чтобы иметь смысл.

В этом случае зависимое условие должно быть помещено после оператора && для предотвращения ошибок.

Рассмотрим выражение (i != 0) && (10 / i == 2) . Зависимое условие (10 / i == 2) должно appear after оператора && чтобы предотвратить возможность деления на ноль.

другой пример (myObject != null) && (myObject.getValue() == somevaluse)

и другое: && и || называются оценкой короткого замыкания, поскольку второй аргумент выполняется или оценивается only if first аргумент not suffice для determine value expression

Ссылки: Java ™ Как программировать (ранние объекты), десятое издание

Interesting Posts
Давайте будем гением компьютера.