Operadores em Java

Operador em java é um símbolo que é usado para executar operações. Por exemplo: +, -, *, / etc.

Existem muitos tipos de operadores em Java que são fornecidos abaixo:

Operador Unário,

Operador aritmético,

Operador shift,

Operador relacional,

Operador bit a bit (bitwise),

Operador lógico,

Operador ternário e

Operador de atribuição.

Precedência de operadores em Java

Tipo de Operador Categoria Precedência
sufixos expr++ expr--
Unário
prefixo ++expr --expr +expr -expr ~ !

multiplicativo */%
Aritmética
aditivo +-

Mudança mudança << >> >>>

comparação < > <= >= instanceof

Relacional
igualdade == !=

bit a bit AND &

Bit a bit bit a bit OR exclusivo ^

bit a bit inclusive OU |

AND lógico &&

Lógico
OR lógico ||

Ternário ternário ?:

Atribuição atribuição = += -= *= /= %= &= ^= |= <<= >>= >>>=

 Operador unário
Os operadores unários requerem apenas um operando. Operadores unários são usados para executar várias operações, ou
seja:

Incrementando / decrementando um valor em um

Negando uma expressão

Invertendo o valor de um boolean

Exemplo de operador unário: ++ e --

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int x = 10;  
4.       System.out.println (x++); // 10 (11)  
5.       System.out.println (++x); // 12  
6.       System.out.println (x--); // 12 (11)  
7.       System.out.println (--x); // 10  
8.    }  
9. }  
Saída:

10
12
12
10

Operador Unário Exemplo 2: ++ e --

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int a = 10;  
4.       int b = 10;  
5.       System.out.println (a++ + ++a); // 10 + 12 = 22  
6.       System.out.println (b++ + b++); // 10 + 11 = 21  
7.    }  
8. }  
Saída:

22
21

Exemplo de operador unário: ~ e !

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int a = 10;  
4.       int b = -10;  
5.       boolean c = true;  
6.       boolean d = false;  
7.       System.out.println (~a); // - 11 (Inverte o sinal e subtrai com 1)  
8.       System.out.println (~b); // 9 (Inverte o sinal e subtrai com 1)  
9.       System.out.println (!c); // false (oposto ao valor booleano)  
10.      System.out.println (!d); // true  
11.   }  
12. }  
Saída:

-11
9
false
true

Operadores aritméticos
Operadores aritméticos são usados para executar: adição, subtração, multiplicação e divisão. Eles agem como operações
matemáticas básicas.

Exemplo de operador aritmético

1. class OperadorExemplo {  
2.    public static void main (String args[]) {   
3.       int a =10;  
4.       int b = 5;  
5.       System.out.println (a + b); // 15  
6.       System.out.println (ab); // 5  
7.       System.out.println (a * b); // 50  
8.       System.out.println (a / b); // 2  
9.       System.out.println (a % b); // 0  
10.   }  
11. }  
Saída:

15
5
50
2
0

Exemplo de operador aritmético: Expressão

1. class OperadorExemplo {  
2.    public static void main (String args[]) {  
3.       System.out.println(10 * 10 / 5 + 3 - 1 * 4 / 2);  
4. }}  
Saída:

21

Operador Shift para a esquerda

O operador Java left shift << é usado para mudar todos os bits de um valor para o lado esquerdo de um número especificado
de vezes.
 Exemplo de operador Left Shift
1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       System.out.println (10 << 2); // 10 * 2 ^ 2 = 10 * 4 = 40  
4.       System.out.println (10 << 3); // 10 * 2 ^ 3 = 10 * 8 = 80  
5.       System.out.println (20 << 2); // 20 * 2 ^ 2 = 20 * 4 = 80  
6.       System.out.println (15 << 4); // 15 * 2 ^ 4 = 15 * 16 = 240  
7.    }  
8. }  
Saída:

40
80
80
240

Operador Shift para a direita

O operador Java right shift >> é usado para mover os operandos da esquerda para a direita pelo número de bits especificado
pelo operando da direita.

Exemplo de operador Right Shift

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       System.out.println (10 >> 2); // 10 / 2 ^ 2 = 10 / 4 = 2  
4.       System.out.println (20 >> 2); // 20 / 2 ^ 2 = 20 / 4 = 5  
5.       System.out.println (20 >> 3); // 20 / 2 ^ 3 = 20 / 8 = 2  
6.    }  
7. }  
Saída:

2
5
2

Exemplo do operador  Shift: >> vs >>>

>

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       // Para número positivo, >> e >>> funcionam da mesma forma  
4.       System.out.println (20 >> 2);  
5.       System.out.println (20 >>> 2);  
6.       // Para número negativo, >>> altera o bit de paridade (MSB) para 0  
7.      System.out.println (-20 >> 2);  
8.      System.out.println (-20 >>> 2);  
9.    }  
10. }  
Saída:
 5
5
-5
1073741819

Exemplo do operador AND: Lógico && e Bitwise &

O operador lógico && não verifica a segunda condição se a primeira condição for falsa. Ele verifica a segunda condição
apenas se a primeira for verdadeira.

O operador bit a bit & sempre verifica as duas condições se a primeira condição é verdadeira ou falsa.

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int a =10;  
4.       int b = 5;  
5.       int c = 20;  
6.       System.out.println (a < b && a < c); // falso && verdadeiro = falso  
7.       System.out.println (a < b & a < c); // falso & verdadeiro = falso  
8.    }  
9. }  
Saída:

false
false

Exemplo do operador AND: Lógico && vs Bitwise &

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int a =10;  
4.       int b = 5;  
5.       int c = 20;  
6.       System.out.println(a < b && a++ < c); // falso && verdadeiro = falso  
7.       System.out.println(a); // 10 porque a segunda condição não está marcada  
8.       System.out.println(a < b & a++ < c); // falso && verdadeiro = falso  
9.       System.out.println(a); // 11 porque a segunda condição está marcada  
10.   }  
11. }  
Saída:

false
10
false
11

Exemplo de operador OR: Lógico || e bit a bit |

O operador lógico || não verifica a segunda condição se a primeira condição for verdadeira. Ele verifica a segunda condição
apenas se a primeira for falsa.

O operador bit a bit | sempre verifica as duas condições se a primeira condição é verdadeira ou falsa.

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int a = 10;  
4.       int b = 5;  
5.       int c = 20;  
6.       System.out.println(a > b || a < c); // true || true = true  
7.       System.out.println(a > b | a < c); // true | true = true  
8.       // ||vs |  
9.       System.out.println (a > b || a ++ < c); // true || true = true  
10.      System.out.println (a); // 10 porque a segunda condição não está marcada  
11.      System.out.println (a > b | a ++ < c); // true | true = true  
12.      System.out.println (a); // 11 porque a segunda condição está marcada  
13.   }  
14. }  
Saída:

true
true
true
10
true
11

Operador Ternário
O operador ternário é usado como um substituto para a instrução if-then-else e muito usado na programação Java. É o único
operador condicional que leva três operandos.

Exemplo de operador ternário Java

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int a = 2;  
4.       int b = 5;  
5.       int min = (a < b) ? a : b;  
6.       System.out.println(min);  
7.    }  
8. }  
Saída:

2
Outro exemplo:

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int a = 10;  
4.       int b = 5;  
5.       int min = (a < b) ? a : b;  
6.       System.out.println (min);  
7.    }  
8. }  
 Saída:

Operador de atribuição
O operador de atribuição é um dos operadores mais comuns. É usado para atribuir o valor à direita ao operando à esquerda.

Exemplo de operador de atribuição

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       int a = 10;  
4.       int b = 20;  
5.       a += 4; //a = a + 4 (a = 10 + 4)  
6.       b -= 4; //b = b - 4 (b = 20 - 4)  
7.       System.out.println(a);  
8.       System.out.println(b);  
9.    }  
10. }  
Saída:

14
16

Exemplo de operador de atribuição Java

1. class OperadorExemplo {  
2.    public static void main (String [] args) {  
3.       int a =10;  
4.       a += 3; // 10 + 3  
5.       System.out.println(a);  
6.       a -= 4; //13 - 4  
7.  System.out.println(a);  
8.  a *= 2; // 9 * 2  
9.  System.out.println(a);  
10. a /= 2; // 18 / 2  
11.     System.out.println(a);  
12.   }  
13. }  
Saída:

13
9
18
9

Exemplo de operador de atribuição: Adicionando short

1. class OperadorExemplo {  
2. public static void main (String args []) {  
3.    short a = 10;  
4.    short b = 10;  
5.    //a += b; //a = a + b internamente tem o mesmo resultado  
6.     a = a + b; // Erro em tempo de compilação porque 10 + 10 = 20 agora int  
7.     System.out.println(a);  
8. }  
9. }  
Saída:

Erro de tempo de compilação

Após alteração no tipo:

1. class OperadorExemplo {  
2.    public static void main (String args []) {  
3.       short a =10;  
4.  short b =10;  
5.  a = (short) (a + b); // 20, que agora é convertido para short  
6.  System.out.println(a);  
7.    }  
8. }  
Saída:

20