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
Unário	sufixos	expr++ expr--
Unário	prefixo	++expr --expr +expr -expr ~ !
Aritmética	multiplicativo	* / %
Aritmética	aditivo	+ -
Mudança	mudança	<< >> >>>
Relacional	comparação	< > <= >= instanceof
Relacional	igualdade	== !=
Bit a bit	bit a bit AND	&
	bit a bit OR exclusivo	^
	bit a bit inclusive OU	\|
Lógico	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 --

class OperadorExemplo {
   public static void main (String args []) {
      int x = 10;
      System.out.println (x++); // 10 (11)
      System.out.println (++x); // 12
      System.out.println (x--); // 12 (11)
      System.out.println (--x); // 10
   }
}

Saída:

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

class OperadorExemplo {
   public static void main (String args []) {
      int a = 10;
      int b = 10;
      System.out.println (a++ + ++a); // 10 + 12 = 22
      System.out.println (b++ + b++); // 10 + 11 = 21
   }
}

Saída:

22
21

Exemplo de operador unário: ~ e !

class OperadorExemplo {
   public static void main (String args []) {
      int a = 10;
      int b = -10;
      boolean c = true;
      boolean d = false;
      System.out.println (~a); // - 11 (Inverte o sinal e subtrai com 1)
      System.out.println (~b); // 9 (Inverte o sinal e subtrai com 1)
      System.out.println (!c); // false (oposto ao valor booleano)
      System.out.println (!d); // true
   }
}

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

class OperadorExemplo {
   public static void main (String args[]) { 
      int a =10;
      int b = 5;
      System.out.println (a + b); // 15
      System.out.println (ab); // 5
      System.out.println (a * b); // 50
      System.out.println (a / b); // 2
      System.out.println (a % b); // 0
   }
}

Saída:

Exemplo de operador aritmético: Expressão

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

Saída:

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

class OperadorExemplo {
   public static void main (String args []) {
      System.out.println (10 << 2); // 10 * 2 ^ 2 = 10 * 4 = 40
      System.out.println (10 << 3); // 10 * 2 ^ 3 = 10 * 8 = 80
      System.out.println (20 << 2); // 20 * 2 ^ 2 = 20 * 4 = 80
      System.out.println (15 << 4); // 15 * 2 ^ 4 = 15 * 16 = 240
   }
}

Saída:

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

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

Saída:

2
5
2

Exemplo do operador Shift: >> vs >>>

class OperadorExemplo {
   public static void main (String args []) {
      // Para número positivo, >> e >>> funcionam da mesma forma
      System.out.println (20 >> 2);
      System.out.println (20 >>> 2);
      // Para número negativo, >>> altera o bit de paridade (MSB) para 0
     System.out.println (-20 >> 2);
     System.out.println (-20 >>> 2);
   }
}

Saída:

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.

class OperadorExemplo {
   public static void main (String args []) {
      int a =10;
      int b = 5;
      int c = 20;
      System.out.println (a < b && a < c); // falso && verdadeiro = falso
      System.out.println (a < b & a < c); // falso & verdadeiro = falso
   }
}

Saída:

false
false

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

class OperadorExemplo {
   public static void main (String args []) {
      int a =10;
      int b = 5;
      int c = 20;
      System.out.println(a < b && a++ < c); // falso && verdadeiro = falso
      System.out.println(a); // 10 porque a segunda condição não está marcada
      System.out.println(a < b & a++ < c); // falso && verdadeiro = falso
      System.out.println(a); // 11 porque a segunda condição está marcada
   }
}

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.

class OperadorExemplo {
   public static void main (String args []) {
      int a = 10;
      int b = 5;
      int c = 20;
      System.out.println(a > b || a < c); // true || true = true
      System.out.println(a > b | a < c); // true | true = true
      // ||vs |
      System.out.println (a > b || a ++ < c); // true || true = true
      System.out.println (a); // 10 porque a segunda condição não está marcada
      System.out.println (a > b | a ++ < c); // true | true = true
      System.out.println (a); // 11 porque a segunda condição está marcada
   }
}

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

class OperadorExemplo {
   public static void main (String args []) {
      int a = 2;
      int b = 5;
      int min = (a < b) ? a : b;
      System.out.println(min);
   }
}

Saída:

Outro exemplo:

class OperadorExemplo {
   public static void main (String args []) {
      int a = 10;
      int b = 5;
      int min = (a < b) ? a : b;
      System.out.println (min);
   }
}

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

class OperadorExemplo {
   public static void main (String args []) {
      int a = 10;
      int b = 20;
      a += 4; //a = a + 4 (a = 10 + 4)
      b -= 4; //b = b - 4 (b = 20 - 4)
      System.out.println(a);
      System.out.println(b);
   }
}

Saída:

14
16

Exemplo de operador de atribuição Java

class OperadorExemplo {
   public static void main (String [] args) {
      int a =10;
      a += 3; // 10 + 3
      System.out.println(a);
      a -= 4; //13 - 4
 System.out.println(a);
 a *= 2; // 9 * 2
 System.out.println(a);
 a /= 2; // 18 / 2
     System.out.println(a);
   }
}

Saída:

Exemplo de operador de atribuição: Adicionando short

class OperadorExemplo {
public static void main (String args []) {
   short a = 10;
   short b = 10;
   //a += b; //a = a + b internamente tem o mesmo resultado
    a = a + b; // Erro em tempo de compila��o porque 10 + 10 = 20 agora int
    System.out.println(a);
}
}

Saída:

Erro de tempo de compilação

Após alteração no tipo:

class OperadorExemplo {
   public static void main (String args []) {
      short a =10;
 short b =10;
 a = (short) (a + b); // 20, que agora é convertido para short
 System.out.println(a);
   }
}

Saída:

Próximo tópicoKeywords do Java

← prev próxima →