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

Ответ 1

& < - проверяет оба операнда
& & < - останавливает оценку, если первый операнд оценивает значение 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).

EDIT:

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

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

Ответ 2

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

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

Ответ 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

Ответ 4

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

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

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

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

Ответ 5

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

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

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

Ответ 6

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

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

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

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

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

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

Ответ 7

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

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

Ответ 8

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

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

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

& и && могут быть логическими 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
}

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

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

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

На странице wiki:

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

Ответ 9

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

Разница лежит за сценой, где обрабатывается информация. Когда вы правы выражения "(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

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

Ответ 10

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

Например: - Условие1 && Condition2

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

Если Condition1 истинно, тогда условие 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

Ответ 11

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

Ответ 12

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

В выражениях, использующих оператор & &, условие-well, называет это 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 ™ Как программировать (ранние объекты), десятое издание

Ответ 13

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