Introdução aos operadores Scala
Os operadores são usados para executar computação lógica e matemática em qualquer linguagem de programação. O Scala também possui vários operadores para executar vários cálculos e tarefas, mas eles são implementados como métodos, pois o Scala é uma linguagem orientada a objetos, portanto, trata cada símbolo como objeto e a operação como método. Eles tornam a computação simples e fácil.
Diferentes operadores presentes no Scala são:
- Operadores aritméticos
- Operadores de atribuição
- Operadores relacionais
- Operadores lógicos
- Operadores bit a bit
Agora vamos estudar cada operador em detalhes.
Operadores aritméticos da Scala
Esses operadores são usados para executar cálculos ou cálculos matemáticos.
| Operador | Símbolo | Explicação | Formato |
| Adição | + | Adiciona os dois operandos | x + y |
| Subtração | - | Subtrai o operando direito do esquerdo | x - y |
| Multiplicação | * | Multiplica ambos os operandos | x * y |
| Divisão | / | Divida o numerador pelo denominador | x / y |
| Módulo | % | Retorna o restante após a divisão | x% y |
Exemplo: Operadores Aritméticos em Scala
object Arith (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a + b);
println (a – b);
println (a * b);
println (a / b);
println (a % b)
)
)
Resultado:
scala> Arith.main (nulo)
15
5
50.
2
0 0
Operadores de atribuição Scala
Esses operadores são usados para atribuir valores a uma variável ou a um objeto.
| Operador | Símbolo | Explicação | Formato |
| Tarefa | = | Atribui o valor do operando direito ao operando esquerdo | x = y + z |
| Adição | + = | Adiciona os dois operandos e, finalmente, atribui o valor ao operando esquerdo | x + = y |
| Subtração | - = | Subtrai o operando direito da esquerda e, em seguida, atribua o valor ao operando esquerdo | x - = y |
| Multiplicação | * = | Multiplica os dois operandos e atribui o valor ao operando esquerdo | x * = y |
| Divisão | / = | Divide o operando esquerdo pelo operando direito e atribui o valor ao operando esquerdo | x / = y |
| Módulo | % = | Avalia o módulo de dois operandos e atribui o valor ao operando esquerdo | x% = y |
| AND bit a bit | & = | Compara o valor binário de dois operandos, retorne 1 se ambos os operandos forem 1, retorne 0 e atribua o valor ao operando esquerdo | x & = 5 |
| OR bit a bit | | = | Compara o valor binário de dois operandos, retorne 0 se ambos os operandos forem 0 ou retorne 1 e atribua o valor ao operando esquerdo | x | = 5 |
| Bitwise XOR | = | Compara o valor binário de dois operandos, retorne 0 se os dois operandos forem iguais; caso contrário, retorne 1 e atribua o valor ao operando esquerdo | x = 5 |
| Desvio à esquerda | << = | Desloca os bits para a esquerda e atribui o resultado ao operando esquerdo | x << = 5 |
| Deslocamento para a direita | >> = | Desloca os bits para a direita e atribui o resultado ao operando esquerdo | x >> = 5 |
Exemplo: operadores de atribuição no Scalaobject Assign (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a += b);
println (a –= b);
println (a *= b);
println (a /= b);
println (a %= b);
a = 20;
b = 15;
println (a &= b);
println (a |= b);
println (a ^= b);
println (a <<= 2);
println (a >>= 2);
)
)
Resultado:
scala> Assign.main (null)
15
10
50.
10
0 0
4
11
4
16
4
Operadores relacionais Scala
Esses operadores retornam valor booleano após verificar as condições mencionadas.
| Operador | Símbolo | Explicação | Formato |
| Igual a | == | Retorna verdadeiro se ambos os operandos forem iguais, senão retornará falso | x == y |
| Diferente de | ! = | Retorna true se ambos os operandos não forem iguais, caso contrário, retorne false | x! = y |
| Maior que | > | Retorna true se o operando esquerdo for maior que o direito, caso contrário, retorne false | x> y |
| Menor que | < | Retorna true se o operando esquerdo for menor que o direito, caso contrário, retorne false | x <y |
| Melhor que ou igual a | > = | Retorna true se o operando esquerdo for maior que ou igual ao da direita, retornar false | x> = y |
| Menos que ou igual a | <= | Retorna true se o operando esquerdo for menor que ou igual ao da direita, retornar false | x <= y |
Exemplo: Operadores relacionais no scala
object Relation (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a == b);
println (a != b);
println (a > b);
println (a < b);
println (a >= b);
println (a <= b);
)
)
Resultado:
scala> Relation.main (nulo)
falso
verdade
verdade
falso
verdade
falso
Operador lógico Scala
Esses operadores também retornam valor booleano de acordo com as entradas ou operandos.
| Operador | Símbolo | Explicação | Formato |
| AND lógico | && | Retorna true se ambos os operandos são diferentes de zero. | x && y |
| OR lógico | || | Retorna true se qualquer um dos operandos for diferente de zero, caso contrário, retorne false | x || y |
| NÃO lógico | ! | Inverte o operando. Retorna verdadeiro para falso e vice-versa | ! x |
Exemplo: Operadores Lógicos no Scala
object Logic (
def main (args: Array (String)) (
var a = true;
var b = false;
println (a && b);
println (a || b);
println !(b);
)
)
Resultado:
scala> Logic.main (null)
falso
verdade
verdade
Operadores Scala Bitwise
Esses operadores trabalham com bits e retornam o valor inteiro correspondente como saída.
| Operador | Símbolo | Explicação | Formato |
| Binário AND | & | Verifique os operandos bit a bit e retorne 1 se os dois bits forem 1, retorne 0 | x & y |
| OR binário | | | Verifique os operandos bit a bit e retorne 0 se ambos os bits forem 0, retorne 1 | x y |
| XOR binário | ^ | Verifique os operandos bit a bit e retorne 0 se os dois bits forem iguais, senão retorne 1 | x y |
| Binário NÃO | ~ | Retorna os complementos, isto é, muda de 1 para 0 e vice-versa | ~ x |
| Deslocamento binário à esquerda | << | Os bits do operando esquerdo são deslocados para o lado esquerdo pelo número de bits mencionados pelo operando direito | x << 3 |
| Deslocamento binário à direita | >> | Os bits do operando esquerdo são deslocados para o lado direito pelo número de bits mencionado pelo operando direito | x >> 3 |
| Preenchimento zero de binário à direita | >>> | Os bits do operando esquerdo são deslocados para o lado direito pelo número de bits mencionados pelo operando direito e os valores deslocados são substituídos por zeros. | x >>> 3 |
Exemplo: Operadores bit a bit no Scala
object Bit (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a & b);
println (a | b);
println (a b);
println ( ~ b);
a = 16;
b = 12;
println (a >> b);
println (a << b);
println (a >>> b);
)
)
Resultado:
scala> Bit. principal (nulo)
0 0
15
15
10
4
64
4
Artigos recomendados
Este foi um guia para os operadores Scala. Aqui discutimos diferentes tipos de operadores Scala, como operadores aritméticos, operadores de atribuição, operadores relacionais, operadores lógicos e operadores bit a bit com exemplos. Você também pode consultar os seguintes artigos para saber mais -
- Usos de Scala
- Haskell vs Scala
- Scala: a abordagem funcional
- Operadores MySQL