Java logical operator short-circuiting

Какой набор является коротким замыканием, и что именно означает, что сложное условное выражение является коротким замыканием?

public static void main(String[] args) {
  int x, y, z;

  x = 10;
  y = 20;
  z = 30;

  // T T
  // T F
  // F T
  // F F

  //SET A
  boolean a = (x < z) && (x == x);
  boolean b = (x < z) && (x == z);
  boolean c = (x == z) && (x < z);
  boolean d = (x == z) && (x > z);
  //SET B    
  boolean aa = (x < z) & (x == x);
  boolean bb = (x < z) & (x == z);
  boolean cc = (x == z) & (x < z);
  boolean dd = (x == z) & (x > z);

}

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

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

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

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


• true || ... - необязательно знать, что такое правая часть, потому что результатом может быть только true независимо от значения там

Давайте сравним поведение в простом примере:

public boolean longerThan(String input, int length) {
    return input != null && input.length() > length;
}

public boolean longerThan(String input, int length) {
    return input != null & input.length() > length;
}

2-я версия использует оператор без короткого замыкания & и выдает NullPointerException if input is null, но 1-я версия вернет false без исключения.

SET A использует логические операторы короткого замыкания.

Что означает "короткое замыкание" в контексте логических операторов, так это то, что для набора логических значений b1, b2, ..., bn версии короткого замыкания прекратят вычисление, как только первое из этих логических значений станет true (||) или false (&&).

Например:

// 2 == 2 will never get evaluated because it is already clear from evaluating
// 1 != 1 that the result will be false.
(1 != 1) && (2 == 2)

// 2 != 2 will never get evaluated because it is already clear from evaluating
// 1 == 1 that the result will be true.
(1 == 1) || (2 != 2)

Короткое замыкание означает, что второй оператор не будет проверен, если первый оператор решит конечный результат.

Например. Выражение: True || False

В случае || все, что нам нужно, это, чтобы одна из сторон была истинной. Итак, если левая часть имеет значение true , нет смысла проверять правую часть, и, следовательно, это вообще не будет проверяться.

Аналогично, False && True

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

boolean a = (x < z) && (x == x);

Этот тип приведет к короткому замыканию, что означает, что если (x < z) вычисляется как false, то последнее не вычисляется, a будет false, в противном случае && также будет вычисляться (x == x).

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

Вы можете протестировать их следующим образом (посмотрите, сколько раз вызывается метод в каждом случае):

public static boolean getFalse() {
    System.out.println("Method");
    return false;
}

public static void main(String[] args) {
    if(getFalse() && getFalse()) { }        
    System.out.println("=============================");        
    if(getFalse() & getFalse()) { }
}