Nuances of working with various operators

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.

9

Task

New Java Syntax, level 9, lesson 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

Open

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:

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

Task

New Java Syntax, level 9, lesson 7

Locked

Flipping strings

Using a StringBuilder in the reverseString(String) method, reverse the string that is received as a parameter.

Open

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;

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.