## 자바 논리 연산자 단락

어떤 세트가 단락되고 복잡한 조건식이 단락된다는 것은 정확히 무엇을 의미합니까?

```
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;
}
```

두 번째 버전은 비 단락 연산자를 사용 `&`

하고 `NullPointerException`

if `input`

is 를 던지지 `null`

만 첫 번째 버전은 `false`

예외없이 반환 됩니다.

SET A uses short-circuiting boolean operators.

What 'short-circuiting' means in the context of boolean operators is that for a set of booleans b1, b2, ..., bn, the short circuit versions will cease evaluation as soon as the first of these booleans is true (||) or false (&&).

For example:

```
// 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)
```

Short circuiting means the second operator will not be checked if the first operator decides the final outcome.

E.g. Expression is: True || False

In case of ||, all we need is ** one of the side** to be True. So if the left hand side is true, there is no point in checking the right hand side, and hence that will not be checked at all.

Similarly, False && True

In case of &&, we need ** both sides** to be True. So if the left hand side is False, there is no point in checking the right hand side, the answer has to be False. And hence that will not be checked at all.

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

This kind will short-circuit, meaning if `(x < z)`

evaluates to false then the latter is not evaluated, `a`

will be false, otherwise `&&`

will also evaluate `(x == x)`

.

`&`

is a bitwise operator, but also a boolean AND operator which does not short-circuit.

You can test them by something as follows (see how many times the method is called in each case):

```
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()) { }
}
```

In plain terms, *short-circuiting* means stopping evaluation once you know that the answer can no longer change. For example, if you are evaluating a chain of logical `AND`

s and you discover a `FALSE`

in the middle of that chain, you know the result is going to be false, no matter what are the values of the rest of the expressions in the chain. Same goes for a chain of `OR`

s: once you discover a `TRUE`

, you know the answer right away, and so you can skip evaluating the rest of the expressions.

You indicate to Java that you want short-circuiting by using `&&`

instead of `&`

and `||`

instead of `|`

. The first set in your post is short-circuiting.

Note that this is more than an attempt at saving a few CPU cycles: in expressions like this

```
if (mystring != null && mystring.indexOf('+') > 0) {
...
}
```

short-circuiting means a difference between correct operation and a crash (in the case where mystring is null).

Java provides two interesting Boolean operators not found in most other computer languages. These secondary versions of AND and OR are known as *short-circuit logical operators*. As you can see from the preceding table, the OR operator results in true when A is true, no matter what B is.

Similarly, the AND operator results in false when A is false, no matter what B is. If you use the `||`

and `&&`

forms, rather than the `|`

and `&`

forms of these operators, Java will not bother to evaluate the right-hand operand alone. This is very useful when the right-hand operand depends on the left one being true or false in order to function properly.

For example, the following code fragment shows how you can take advantage of short-circuit logical evaluation to be sure that a division operation will be valid before evaluating it:

```
if ( denom != 0 && num / denom >10)
```

Since the short-circuit form of AND (`&&`

) is used, there is no risk of causing a run-time exception from dividing by zero. If this line of code were written using the single `&`

version of AND, both sides would have to be evaluated, causing a run-time exception when `denom`

is zero.

It is standard practice to use the short-circuit forms of AND and OR in cases involving Boolean logic, leaving the single-character versions exclusively for bitwise operations. However, there are exceptions to this rule. For example, consider the following statement:

```
if ( c==1 & e++ < 100 ) d = 100;
```

Here, using a single `&`

ensures that the increment operation will be applied to `e`

whether `c`

is equal to 1 or not.

Logical OR :- returns true if at least one of the operands evaluate to true. Both operands are evaluated before apply the OR operator.

Short Circuit OR :- if left hand side operand returns true, it returns true without evaluating the right hand side operand.

There are a couple of differences between the `&`

and `&&`

operators. The same differences apply to `|`

and `||`

. The most important thing to keep in mind is that `&&`

is a *logical* operator that only applies to boolean operands, while `&`

is a *bitwise* operator that applies to integer types as well as booleans.

With a logical operation, you can do short circuiting because in certain cases (like the first operand of `&&`

being `false`

, or the first operand of `||`

being `true`

), you do not need to evaluate the rest of the expression. This is very useful for doing things like checking for `null`

before accessing a filed or method, and checking for potential zeros before dividing by them. For a complex expression, each part of the expression is evaluated recursively in the same manner. For example, in the following case:

(7 == 8)|| ((1 == 3)&& (4 == 4))

Only the emphasized portions will evaluated. To compute the `||`

, first check if `7 == 8`

is `true`

. If it were, the right hand side would be skipped entirely. The right hand side only checks if `1 == 3`

is `false`

. Since it is, `4 == 4`

does not need to be checked, and the whole expression evaluates to `false`

. If the left hand side were `true`

, e.g. `7 == 7`

instead of `7 == 8`

, the entire right hand side would be skipped because the whole `||`

expression would be `true`

regardless.

With a bitwise operation, you need to evaluate all the operands because you are really just combining the bits. Booleans are effectively a one-bit integer in Java (regardless of how the internals work out), and it is just a coincidence that you can do short circuiting for bitwise operators in that one special case. The reason that you can not short-circuit a general integer `&`

or `|`

operation is that some bits may be on and some may be off in either operand. Something like `1 & 2`

yields zero, but you have no way of knowing that without evaluating both operands.

```
if(demon!=0&& num/demon>10)
```

Since the short-circuit form of AND(&&) is used, there is no risk of causing a run-time exception when demon is zero.

Ref. Java 2 Fifth Edition by Herbert Schildt

참고URL : https://stackoverflow.com/questions/8759868/java-logical-operator-short-circuiting

#### 'Programing' 카테고리의 다른 글

TCPServer 오류 : 주소가 이미 사용 중입니다. bind (2) (0) | 2020.09.08 |
---|---|

두 목록의 공통 요소 (0) | 2020.09.08 |

Kubernetes에서 컨테이너를 계속 실행하려면 어떻게해야합니까? (0) | 2020.09.08 |

127.0.0.1:6379에서 Redis에 연결할 수 없음 : 홈브류로 연결이 거부되었습니다. (0) | 2020.09.08 |

위치 관리자 오류 : (KCLErrorDomain 오류 0) (0) | 2020.09.08 |