Nuances de trabalhar com vários operadores

1. Operações booleanas

Os operadores |e &podem ser aplicados não apenas a números, mas também a expressões booleanas.

Mas, como você já sabe, existem &&e ||operadoras. Por que usaríamos |em vez de ||e &em vez de &&? Existe algum ponto para isso? Parece que existe. Às vezes.

Os operadores lógicos ||e &&são executados da esquerda para a direita seguindo o chamado princípio preguiçoso .

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

Se expression1 for igual a true, não adianta avaliar expression2 e expression3: o resultado será trueindiferente.

Assim, ao avaliar expressões (elas são avaliadas da esquerda para a direita), assim que obtemos true, a avaliação do restante das expressões é ignorada . E se expression2 e expression3incluir chamadas de método, esses métodos não serão chamados !

O mesmo vale para o &&operador lógico:

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

Se expression1for igual a false, não adianta avaliar expression2e expression3: o resultado será falseindiferente.

Este é um fato importante que permite escrever coisas como:

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

O exemplo acima nunca vai te dar um NullPointerException , pois s.length()só será executado se a primeira parte s! = nullfor true.

Se sfor igual a null, a parte à esquerda do &&operador é false, então o resultado de toda a expressão booleana é false, portanto a parte à direita ( s.length() > 0) não é avaliada.

2. Precedência de operação em Java

Como você provavelmente se lembra de sua aula de matemática do ensino médio, o operador de multiplicação tem maior precedência do que o operador de adição. Os parênteses têm uma precedência ainda maior: as expressões entre parênteses são avaliadas primeiro, depois a multiplicação e a divisão e, por fim, a adição e a subtração.

Os operadores em Java também têm uma ordem de precedência. A diferença é que a) há um pouco mais deles, b) para alguns operadores, os operandos são avaliados da esquerda para a direita, enquanto para outros - da direita para a esquerda.

Aqui está uma tabela com todos os operadores Java:

A linha superior contém os operadores com a precedência mais alta. Os parênteses ()são usados ​​para definir explicitamente a prioridade. Os colchetes []são usados ​​para acessar um elemento em um índice específico de uma variável de matriz. O operador ponto ( .) é usado para acessar campos e métodos usando uma referência a um objeto ou classe.

Quanto mais baixo os operadores estiverem na tabela, menor será sua precedência.

Se você usar vários operadores em uma expressão, não seja preguiçoso: adicione parênteses.

Em Java, você pode escrever algo como if (a & 1<< b > ~c), mas não deveria. Você está escrevendo código não apenas para o compilador, mas também para outros programadores. Quanto mais legível for o código, melhor.

3. Incremento de prefixo e pós-fixo

Como você já sabe, Java possui um operador de incremento ( ++) e um operador de decremento ( --). Respectivamente, eles aumentam e diminuem o valor de uma variável em 1.

O que você provavelmente não sabe é que existem dois tipos desses operadores: prefix (o operador é colocado antes da variável) e postfix (o operador é colocado após a variável). E dois tipos de operadores funcionam de maneira um pouco diferente.

Em Java, você pode escrever uma expressão como esta:

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

Se o ++operador aparecer depois de uma variável e a variável fizer parte de alguma expressão (como no exemplo acima), então a expressão usará o valor atual da variável e somente depois a variável será aumentada em 1.

Em outras palavras, algo assim acontecerá:

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

Ou seja , não bserá como você pode pensar à primeira vista.56

Se o ++operador estiver antes da variável e a variável fizer parte de alguma expressão, primeiro ela será incrementada 1e só depois seu valor será utilizado na expressão.

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

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

Aqui, bserá igual a 6.

Existe até um exemplo usado por programadores Java para determinar se outra pessoa também é um programador Java:

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

Sim, você pode escrever isso também.

Este exemplo irá compilar perfeitamente e se transformar em algo assim:

int a = 5;

a = a + 1;
int v1 = a;

a = a + 1;
int v2 = a;

int b = v1 + v2;

Para o --operador, tudo é exatamente igual.