Различия в логических операторах: & против && и | против ||

Это операторы побитового И и побитового ИЛИ.

int a = 6; // 110
int b = 4; // 100

// Bitwise AND    

int c = a & b;
//   110
// & 100
// -----
//   100

// Bitwise OR

int d = a | b;
//   110
// | 100
// -----
//   110

System.out.println(c); // 4
System.out.println(d); // 6

Спасибо Карлосу за указание на соответствующий раздел в спецификации языка Java (15.22.1, 15.22.2) относительно различного поведения оператора на основе его входных данных.

Действительно, когда оба входа являются булевыми, операторы считаются булевыми логическими операторами и ведут себя аналогично операторам условного И (&&) и условного ИЛИ (||), за исключением того факта, что они не замыкаются, поэтому при выполнении следующих безопасно:

if((a != null) && (a.something == 3)){
}

Это не:

if((a != null) & (a.something == 3)){
}

Короткое замыкание означает, что оператор не обязательно проверяет все условия. В приведенных выше примерах && будет проверять второе условие только тогда, когда a не является null (иначе весь оператор вернет false, и в любом случае было бы спорно проверять следующие условия), поэтому оператор a.something не вызовет исключение, или считается безопасным.

Оператор & всегда проверяет каждое условие в предложении, поэтому в приведенных выше примерах a.something может оцениваться, когда a на самом деле является значением null, вызывая исключение.

Я думаю, вы говорите о логическом значении обоих операторов, вот вам таблица-резюме:

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

Краткая оценка, минимальная оценка или оценка Маккарти ( после Джона Маккарти) — это семантика некоторых логических операторов в некоторых языках программирования, в которых второй аргумент выполняется или оценивается только в том случае, если первого аргумента недостаточно для определения значения выражения: когда первый аргумент функции И оценивается как false, общее значение должно быть false; и когда первый аргумент функции ИЛИ оценивается как истина, общее значение должно быть истинным.

Небезопасно означает, что оператор всегда проверяет каждое условие в предложении, поэтому в приведенных выше примерах 1/x может оцениваться, когда x на самом деле имеет значение 0, вызывая исключение.

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

Логическое И: Логическое И (также известное как Условное И) использует оператор &&. Это укороченное значение: если левый операнд ложен, то правый операнд не будет оцениваться.
Пример:

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

В приведенном выше примере значение, напечатанное на консоли x, будет равно 0, потому что первый операнд в операторе if ложен, поэтому java не нужно вычислять (1 == ++x), поэтому x не будет вычисляться.

Побитовое И: Побитовое И использует оператор &. Он используется для выполнения побитовой операции над значением. Гораздо проще увидеть, что происходит, посмотрев на операцию с двоичными числами, например:

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

Как вы можете видеть в примере, когда двоичные представления чисел 5 и 12 выстроены в ряд, то предварительно сформированное побитовое И даст только двоичное число, в котором одна и та же цифра в обоих числах имеет 1. Следовательно, 0101 и 1100 == 0100. Что в десятичном виде равно 5 и 12 == 4.

Логическое И: теперь логическое И ведет себя одинаково и по-разному как побитовое И, так и логическое И. Мне нравится думать об этом как о предварительном формировании побитового И между двумя логическими значениями (или битами), поэтому он использует оператор &. Логические значения также могут быть результатом логического выражения.

Он возвращает либо истинное, либо ложное значение, подобно логическому И, но в отличие от логического И не имеет короткого замыкания. Причина в том, что для выполнения этого побитового И необходимо знать значение как левого, так и правого операндов. Вот бывший:

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

Теперь, когда выполняется оператор if, выражение (1 == ++x) будет выполнено, даже если левый операнд ложен. Следовательно, значение, напечатанное для x, будет равно 1, потому что оно было увеличено.

Это также относится к логическому ИЛИ (||), побитовому ИЛИ (|) и логическому ИЛИ (|). Надеюсь, это прояснит некоторую путаницу.

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

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

В Java отдельные операторы &, |, ^, ! зависят от операндов. Если оба операнда являются целыми, то выполняется побитовая операция. Если оба являются логическими, выполняется «логическая» операция.

Если оба операнда не совпадают, возникает ошибка времени компиляции.

Двойные операторы &&, || ведут себя аналогично своим одиночным аналогам, но оба операнда должны быть условными выражениями, например:

if (( a ‹ 0 ) && ( b ‹ 0 )) { ... } или аналогично, if (( a ‹ 0 ) || ( b ‹ 0 )) { ... }

источник: язык программирования Java, 4-е изд.

& и | — это побитовые операторы для целочисленных типов (например, int): http://download.oracle.com/javase/tutorial/java/nutsandbolts/op3.html

&& и || работают только с логическими значениями (и замыкаются накоротко, как уже говорилось в других ответах).

Возможно, будет полезно знать, что побитовые операторы И и побитовые ИЛИ всегда оцениваются перед условным И и условным ИЛИ, используемыми в одном и том же выражении.

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

&& ; || являются логическими операторами.... короткое замыкание

& ; | являются булевыми логическими операторами.... Без короткого замыкания

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

Например:

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

Это напечатает i=26 ; j=25, поскольку первое условие ложно, правостороннее условие игнорируется, так как результат в любом случае ложный, независимо от правостороннего условия (короткое замыкание).

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

Но это напечатает i=26; j=26,

Если оценивается выражение, включающее логический оператор &, оцениваются оба операнда. Затем к операнду применяется оператор &.

Когда вычисляется выражение, включающее оператор &&, вычисляется первый операнд. Если первый операнд оценивается как false, оценка второго операнда пропускается.

Если первый операнд возвращает значение true, то оценивается второй операнд. Если второй операнд возвращает значение true, то оператор && применяется к первому и второму операндам.

Аналогично | и ||.

Хотя основное отличие состоит в том, что & используется для побитовых операций в основном над long, int или byte, где его можно использовать для вида маски, результаты могут отличаться, даже если вы используете его вместо логического &&.

В некоторых сценариях разница более заметна:

1. Вычисление некоторых выражений занимает много времени
2. Вычисление одного из выражений может быть выполнено только в том случае, если предыдущее было истинным.
3. Выражения имеют побочный эффект (преднамеренный или нет)

Первый пункт довольно прост, он не вызывает ошибок, но занимает больше времени. Если у вас несколько разных проверок в одном условном выражении, поставьте те, которые дешевле или с большей вероятностью не пройдут, слева.

Для второго пункта см. этот пример:

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

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

Пример для третьего пункта — допустим, у нас есть приложение, которое использует БД без каких-либо триггеров или каскадов. Прежде чем мы удалим объект Building, мы должны изменить здание объекта Department на другое. Допустим также, что статус операции возвращается как логическое значение (true = успех). Потом:

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

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

Что касается a || b, это эквивалентно !(!a && !b), оно останавливается, если a истинно, больше никаких объяснений не требуется.