1. Boolean operations

The `|` and `&` operators can be applied not only to numbers, but also to boolean expressions.

But, as you already know, there are `&&` and `||` operators. Why would we use `|` instead of `||`, and `&` instead of `&&`? Is there any point to this? It seems that there is. Sometimes.

The `||` and `&&` logical operators are executed from left to right following a so-called lazy principle.

``(expression1) || (expression2) || (expression3)``

If `expression1` is equal to `true`, there is no point in evaluating `expression2` and `expression3`: the result will be `true` regardless.

Accordingly, when evaluating expressions (they are evaluated from left to right), as soon as we get `true`, the evaluation of the rest of the expressions is skipped.  And if `expression2` and `expression3` include method calls, these methods won't be called!

The same goes for the `&&` logical operator:

``(expression1) && (expression2) && (expression3)``

If `expression1` is equal to `false`, there is no point in evaluating `expression2` and `expression3`: the result will be `false` regardless.

This is an important fact that lets you write things like:

``````String s = null;
if (s != null && s.length() > 0) {``````

The example above will never get you a NullPointerException, because `s.length()` will only be executed if the first part `s! = null` is `true`.

If `s` is equal to `null`, the part to the left of the `&&` operator is `false`, then the result of the whole boolean expression is `false`, so the part to the right (`s.length() > 0`) is not evaluated.

All that to say:

If you use the `|` operator or the `&` operator, then there is no lazy evaluation: each subexpression will always be evaluated.

9
New Java Syntax,  level 9lesson 7
Locked
Let's work with StringBuilder
You need to implement 2 methods using a StringBuilder: addTo(String, String[]) and replace(String, String, int, int). 1. The addTo(String, String[]) method adds to the string received as the first parameter, in order, all the strings in the array of strings received as the second parameter and retur

2. Operation precedence in Java

As you probably remember from your high school math class, the multiplication operator has higher precedence than the addition operator. Parentheses have an even higher precedence: expressions in parentheses are evaluated first, then multiplication and division, and then addition and subtraction.

Operators in Java also have a order of precedence. The difference is that a) there are slightly more of them, b) for some operators, the operands are evaluated from left to right, while for others — from right to left.

Here is a table with all the Java operators:

Category Operator Associative
Postfix `()` `[]` `.` From left to right
Unary `++` `--` `!` `~` Right to left
Multiplicative `*` `/` `%` From left to right
Additive `+` `-` From left to right
Shifting `>>` `>>>` `<<` From left to right
Relational `>` `>=` `<` `<=` From left to right
Equality `==` `!=` From left to right
Bitwise `AND` `&` From left to right
`Exclusive OR` (XOR) `^` From left to right
Bitwise `OR` `|` From left to right
Logical `AND` `&&` From left to right
Logical `OR` `||` From left to right
Conditional `?:` Right to left
Assignment `=` `+=` `-=` `*=` `/=` `%=` `>>=` `<<=` `&=` `^=` `|=` Right to left
Comma `,` From left to right

The top line contains the operators with the highest precedence. Parentheses `()` are used to explicitly set the priority. Square brackets `[]` are used to access an element at a specific index of an array variable. The dot operator (`.`) is used to access fields and methods using a reference to an object or class.

The lower the operators are in the table, the lower their precedence.

If you use multiple operators in an expression, don't be lazy: add parentheses.

In Java, you can write something like `if (a & 1<< b > ~c)`, but you shouldn't. You're writing code not only for the compiler, but also for other programmers. The more readable the code, the better.

9
New Java Syntax,  level 9lesson 7
Locked
Flipping strings
Using a StringBuilder in the reverseString(String) method, reverse the string that is received as a parameter.

3. Prefix and postfix increment

As you already know, Java has an increment operator (`++`) and a decrement operator (`--`). Respectively, they increase and decrease the value of a variable by `1`.

What you probably don't know is that there are two types of these operators: prefix (the operator is placed before the variable) and postfix (the operator is placed after the variable). And two kinds of operators work a little differently.

In Java, you can write an expression like this:

``````int a = 5;
int b = a++;``````

If the `++` operator appears after a variable and the variable is part of some expression (as in the example above), then the expression will use the current value of the variable, and only afterward will the variable be increased by `1`.

In other words, something like this will happen:

``````int a = 5;
int b = a;
a = a + 1;``````

That is, `b` will be `5`, not `6` as you might think at first glance.

If the `++` operator is before the variable and the variable is part of some expression, it will first be increased by `1` and only afterward will its value be used in the expression.

``````int a = 5;
int b = ++a;``````

The example above is equivalent to the following example:

``````int a = 5;
a = a + 1;
int b = a;``````

Here, `b` will be equal to `6`.

There's even an example used by Java programmers to determine whether someone else is also a Java programmer:

``````int a = 5;
int b = ++a + ++a;``````

Yep, you can write that too.

This example will compile just fine and turn into something like this:

``````int a = 5;

a = a + 1;
int v1 = a;

a = a + 1;
int v2 = a;

int b = v1 + v2;``````

For the `--` operator, everything is exactly the same.