"Oi, Bilaabo!"
"Bilaabo está feliz em receber seu amigo!"
"Hoje Bilaabo falará sobre a precedência do operador. Mas primeiro ele falará sobre os próprios operadores."
"O que são esses operadores de que você fala?"
"Na verdade, você já está familiarizado com eles. Você só pode não saber que eles são chamados de operadores."
"Por exemplo, digamos que temos a expressão c = a + b; "
"Tem dois operadores: um operador de adição e um operador de atribuição."
"Em outras palavras, operadores são apenas sinais matemáticos? Como multiplicação, divisão e adição?"
"Sim, isso é verdade. No entanto, existem diferenças."
"Não definirei os operadores para você: uma definição não o tornará mais inteligente. É melhor vê-los em ação. Os operadores podem ser divididos em vários grupos, que examinaremos agora."
1) " Operadores matemáticos "
Símbolo | Exemplo | Nome | Descrição (o que faz) |
---|---|---|---|
+ |
a + b |
Operador de adição | Operador de adição. |
- |
c - d |
operador de subtração | Subtrai o segundo número do primeiro. |
* |
a * t |
Operador de multiplicação | Multiplica dois números. |
/ |
a / b |
operador de divisão | Divide o primeiro número pelo segundo. |
% |
c % d |
Divide o primeiro número pelo segundo. | Calcula o resto depois de dividir o primeiro número pelo segundo. |
- |
-a |
menos unário | Muda o sinal da variável para o seu oposto. Mais para menos e menos para mais. |
+ |
+a |
unário mais | Não muda nada. Isso foi adicionado para complementar o operador menos unário. É só para aparência. |
"Eu os reconheço da escola. Meu firmware inclui cursos escolares."
"Mas, o que há com esse sinal de porcentagem, algum tipo de feitiçaria?"
"É o operador " resto após a divisão ". Se 11 é dividido por 5, obtemos 2 e um resto de 1. Esse 1 pode ser obtido escrevendo 11% 5;"
"Quando você divide inteiros em Java, o resultado também é um inteiro. O resto da operação de divisão é simplesmente ignorado. Se dividirmos 8 por 5, obtemos 1."
Expressão | Resultado | |
---|---|---|
19 / 10 |
1 | Se dividirmos 19 por 10, o resultado é 1 com resto 9. |
19 % 10 |
9 | Se dividirmos 19 por 10, o resultado é 1 com resto 9. |
2 / 5 |
0 | Se dividirmos 2 por 5, o resultado é 0 com resto 2. |
16 % 2 |
0 | Se dividirmos 16 por 2, o resultado é 8 com resto 0. |
"Mas para que diabos precisamos do resto?"
"Suponha que você precise verificar se um número inteiro é par. Então você pode escrever:"
if (a % 2 == 0)
"E se você precisar verificar se b é ímpar, poderá escrever:"
if (b % 2 == 1)
"Ou para verificar se d é divisível por 3:"
if (d % 3 == 0)
"Interessante. Vou me lembrar disso."
2) " Operadores de comparação "
Símbolo | Exemplo | Nome | Descrição (o que faz) |
---|---|---|---|
< |
a < b |
Menor que | Verifica se a é menor que b. |
<= |
c <= d |
Menos que ou igual a | Verifica se c é menor ou igual a d. |
> |
a > b |
Maior que | Verifica se a é maior que b. |
>= |
c >= d |
Melhor que ou igual a | Verifica se c é maior ou igual a d. |
== |
i == j |
é igual a | Verifica se i é igual a j. |
!= |
a != 0 |
Diferente de | Verifica se a não é igual a zero. |
"Eu já uso tudo isso."
"E qual é a principal diferença entre esses operadores e os operadores matemáticos?"
"Se somarmos dois números, obtemos um número; mas, se compararmos dois números, obtemos verdadeiro ou falso."
"Isso mesmo. O resultado de uma comparação é um valor de " valor lógico ", que, como você sabe, é representado pelo tipo booleano. Existem duas possibilidades: verdadeiro ou falso.
"Sim, está tudo claro. Eu já sei disso."
3) " Operadores lógicos "
Símbolo | Exemplo | Nome | Descrição (o que faz) |
---|---|---|---|
&& |
a && b |
E | O resultado da expressão é verdadeiro somente quando a e b são verdadeiros. |
|| |
c || d |
OU | O resultado da expressão é verdadeiro se a ou b for verdadeiro. Ambos ou pelo menos um. |
! |
!a |
NÃO | O resultado da expressão é verdadeiro apenas se a for falso. |
"Os operadores lógicos só podem ser usados com variáveis ou expressões booleanas."
Exemplo | Descrição |
---|---|
boolean a = true; boolean b = true;if (a && b) |
A condição if é verdadeira se ambos os valores forem verdadeiros. Em outras palavras, se aeb forem verdadeiros, o resultado será verdadeiro . |
boolean a = true; boolean b = false;if (a || b) |
A condição if é true se pelo menos um valor for true Em outras palavras, se a ou b for true, o resultado será true . |
boolean b = false;
|
A condição if é verdadeira se b não é verdadeiro. Em outras palavras, se b for false , o resultado será true . |
int a = 2, b = 3, c = 4;
|
Se a for menor que b e a for menor que c, o resultado da expressão será verdadeiro. a, b e c são inteiros, mas o resultado da comparação de inteiros é um valor lógico (verdadeiro, falso), o que significa que podemos usar operadores lógicos. |
"Eu já sei de tudo isso."
"Sério? Vamos continuar, então."
4) " Operadores bit a bit "
Símbolo | Exemplo | Nome | Descrição (o que faz) |
---|---|---|---|
& |
a & b |
E | E bit a bit |
| |
c | d |
OU | OU bit a bit |
~ |
~a |
NÃO | NÃO bit a bit |
^ |
a ^ b |
XOR | Bit a bit "EXCLUSIVO OU" |
" Os operadores bit a bit executam operações bit a bit em números inteiros."
"O que é isso?"
"Cada número é representado como um conjunto de bits e, em seguida, o resultado é calculado da seguinte forma:"
"Se o primeiro bit de ambos os números for 1, o primeiro bit do resultado será 1."
"Se o segundo bit de ambos os números for 1, o segundo bit do resultado será 1. E assim por diante."
"Isso é verdade para todos os operadores bit a bit?"
"É muito mais simples do que isso. Um bit só pode ter dois valores, 0 e 1, certo?"
"Certo."
"Então pense em 1 como verdadeiro e 0 como falso. As operações em bits individuais serão quase idênticas às operações lógicas:"
expressão lógica | Expressão bit a bit |
---|---|
verdadeiro && verdadeiro == verdadeiro | 1&1 == 1 |
verdadeiro && falso == falso | 1&0 == 0 |
verdadeiro || verdadeiro == verdadeiro | 1|1 == 1 |
verdadeiro || falso == verdadeiro | 1|0 == 1 |
falso || falso = falso | 0|0 == 0 |
!falso == verdadeiro | ~0 == 1 |
!verdadeiro == falso | ~1 == 0 |
"Oh! Isso é tão fácil."
"Sim, mas não esqueça que as operações bit a bit usam bits correspondentes de dois números."
"Sim, eu me lembro: o primeiro bit de um número é emparelhado com o primeiro bit do segundo, e o resultado também é gravado no primeiro bit. E o mesmo vale para o resto dos bits."
"Isso mesmo. Você tem alguma outra pergunta?"
"O que há com o XOR e 'exclusivo ou'?"
"É moleza: quando os valores são diferentes, é verdadeiro; quando são iguais, é falso."
expressão lógica | Expressão bit a bit |
---|---|
verdadeiro XOR verdadeiro == falso | 1 ^ 1 == 0 |
falso XOR falso == falso | 0 ^ 0 == 0 |
verdadeiro XOR falso == verdadeiro | 1 ^ 0 == 1 |
falso XOR verdadeiro == verdadeiro | 0 ^ 1 == 1 |
Aqui estão mais alguns exemplos de operações bit a bit:
Exemplo | Números como bits | Resultado como bits | Resultado |
---|---|---|---|
5 & 3 |
0000010 1 e 0000001 1 | 0000000 1 | 1 |
7 & 2 |
000001 1 1 e 000000 1 0 | 00000010 | 2 |
5 | 9 |
00000 1 0 1 | 0000 1 00 1 | 00001101 | 13 |
5 ^ 9 |
00000 101 ^ 00001001 | 0000 1100 | 12 |
~9 |
~ 00001001 | 11110110 | 246 |
"Obrigado, Bilaabo. Agora eu sei."
"Existe mais um grupo de operadores bit a bit, os operadores shift:"
5) " Operadores de turno "
Símbolo | Exemplo | Nome | Descrição (o que faz) |
---|---|---|---|
>> |
a >> b |
deslocamento para a direita | Desloca os bits do número a para a direita em b dígitos. |
<< |
c << d |
desvio à esquerda | Desloca os bits do número c para a esquerda em d dígitos. |
>>> |
a >>> 2 |
deslocamento à direita sem sinal | Desloca os bits do número a para a direita em 2 dígitos. |
"Que tipo de mágica de rua é essa?"
"Na verdade, é tudo muito simples. Confira:"
Exemplo | Números como bits | Resultado como bits | Resultado |
---|---|---|---|
10 >> 1 |
0000 101 0 >> 1 | 00000 101 | 5 |
10 >> 2 |
0000 101 0 >> 2 | 000000 10 | 2 |
10 << 1 |
0000 101 0 << 1 | 000 101 00 | 20 |
10 << 2 |
0000 101 0 << 2 | 00 101 000 | 40 |
"Deslocar os bits de um número para a esquerda por 1 é o mesmo que multiplicar o número por 2. Deslocar por dois dígitos é equivalente à multiplicação por 4, por três dígitos - multiplicação por 8 e assim por diante."
"Deslocar para a direita corresponde a dividir por 2, 4, 8, 16, etc."
"Mas qual é a diferença entre os operadores >>> e >>?"
"Eles diferem ao trabalhar com números negativos. Isso ocorre porque os números assinados usam o bit mais à esquerda para indicar o sinal. Como resultado, um número negativo deixa de ser negativo quando se desloca para a direita. Então, eles criaram dois operadores diferentes. Confira:"
Expressão | Resultado | Descrição |
---|---|---|
1 000 1010 >> 1 | 11 000 101 | O número negativo permanece negativo. Para números negativos, os bits recebidos são preenchidos com 1s. |
1 000 1010 >> 2 | 111 000 10 | |
1 000 1010 >> 3 | 1111 000 1 | |
1 000 1010 >>> 1 | 01 000 101 | O número negativo não é mais negativo. Para números negativos, os bits recebidos são preenchidos com 0s. |
1 000 1010 >>> 2 | 001 000 10 | |
1 000 1010 >>> 3 | 0001 000 1 |
"A mudança não é cíclica. Os bits que se movem além da borda esquerda ou direita do número são simplesmente descartados."
6) " Operadores de atribuição "
"Eu já sei o que é atribuição. Mas por que você diz 'operadores'?"
"Porque tem vários ☺"
Operador | O que significa |
---|---|
a += b; |
a = a + b; |
a -= b; |
a = a - b; |
a *= b; |
a = a * b; |
a %= b; |
a = a % b; |
a |= b; |
a = a | b; |
a &= b; |
a = a & b; |
"Eu acho que você entendeu a lógica."
7) " Operadores de incremento e decremento "
Notação | Exemplo | Descrição |
---|---|---|
++ |
a++; ++b; |
Aumenta o número em 1. |
-- |
d--; --i; |
Diminui o número ou variável em 1. |
"Existe uma diferença entre colocar os dois sinais de menos antes ou depois da variável?"
"Sim, existe, embora não seja muito grande. Se uma variável com um desses operadores faz parte de uma expressão ou atribuição, então existem diferenças. Prefiro mostrar a você por exemplo:"
Exemplo | O que realmente acontece | Descrição |
---|---|---|
int a = 3; int b = ++a; |
int a = 3; a = a + 1; int b = a; |
a é primeiro aumentado em 1 e, em seguida, é usado na expressão. |
int a = 3; int b = a++; |
int a = 3; int b = a; a = a + 1; |
a é usado primeiro na expressão e depois aumenta em 1. |
int a = 3; return a++; |
int a = 3; int result = a; a = a + 1; return result; |
A função retornará 3, mas o valor de a será aumentado em 1. |
int x = 5; x = ++x + ++x; |
int x = 5; int a = x + 1;// The first term is 6 x = a; int b = x + 1;// The second term is 7 x = b; x = a + b; |
O resultado aqui é 13. Primeiro, x aumentará em 1 e esse valor substituirá o primeiro termo e, em seguida, x aumentará novamente em 1. |
"Uau! Isso é legal!"
"Estou feliz que você gostou. Mas, se não houver expressão ou atribuição, não haverá diferenças:"
"x++ é equivalente a x = x + 1."
"++x é equivalente a x = x + 1."
"Vou manter isso em mente. Obrigado, Bilaabo."
8) " Operador ternário "
"Este operador não usa apenas uma ou duas variáveis ou expressões. Ele usa três variáveis ou expressões de uma só vez:"
Notação | Código equivalente: |
---|---|
a ? b : c; |
if (a) b else c |
int min = a < b ? a : b; |
if (a < b) min = a; else min = b; |
return a != null ? a.length : 0; |
if (a != null) return a.length; else return 0; |
"Bem, isso é super conveniente."
"Sim. E é compacto e o código é legível. Divirta-se usando-o!"
9) " Outro "
"Não importa o quão bem organizada seja sua coleção de músicas, você ainda precisa criar uma pasta "Diversos"."
"Sim, qualquer um que já teve que categorizar a música concordaria totalmente."
"Então, há mais três operadores sobre os quais quero falar:"
Notação | Exemplo | Descrição |
---|---|---|
() |
(a + b) * c |
Os parênteses aumentam a precedência do operador. As coisas entre parênteses são executadas primeiro. |
[] |
c [i] = c [i + 1]; |
Obtenha um elemento de array por índice. |
. |
int n = a.length; |
O " operador ponto " acessa as variáveis e métodos de um objeto. |
"E, finalmente, aqui está uma tabela que resume a precedência do operador:"
operadores | Exemplos |
---|---|
Maior precedência (os operadores são executados de acordo com sua ordem nesta tabela) | |
() [] . |
(a + b) c [i] = c [i] + 1 |
++ -- ~ ! + - |
i++; ++i; --j; a--; ~c !f return +a; return -a; |
* / % |
a * b c / d a % b |
+ - |
a + b c - d String s = "count"+"35"; |
>> << >>> |
a >> 3 b << 2 c >>> 3 |
< <= > >= |
a < b a <= b c > b c >= b |
== != |
a == 3 a != 0 |
& |
a & 7 |
^ |
a ^ b |
| |
a | b |
&& |
(a < b) && (a < c) |
|| |
(b != 0) || (c != 0) |
? : = |
a > 0 ? a : -a; |
= *=, /=, %= -=, += <<=. >>=, >>>= &=, ^=. |= |
|
Precedência mais baixa (realizada por último) |
GO TO FULL VERSION