operador Scala

Um operador é um símbolo, usado para dizer ao compilador para executar um Determinado operações matemáticas e lógicas.

Scala ricos embutidos operadores, incluindo os seguintes tipos:

• operadores aritméticos

• Operadores relacionais

• Operadores lógicos

• Operadores bit a bit

• Operadores de atribuição

Em seguida, vamos explicar-lhe mais do que a aplicação de vários operadores.

operadores aritméticos

A tabela a seguir lista os operadores de suporte aritméticas Scala.

Uma variável assumida como 10, B 20:

Exemplos

object Test {
   def main(args: Array[String]) {
      var a = 10;
      var b = 20;
      var c = 25;
      var d = 25;
      println("a + b = " + (a + b) );
      println("a - b = " + (a - b) );
      println("a * b = " + (a * b) );
      println("b / a = " + (b / a) );
      println("b % a = " + (b % a) );
      println("c % a = " + (c % a) );
      
   }
}

Correndo instância »

Implementação do código acima, a saída é:

$ scalac Test.scala 
$ scala Test
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5

Operadores relacionais

A tabela a seguir lista o Scala apoiar os operadores relacionais.

Uma variável assumida como 10, B 20:

Exemplos

object Test {
   def main(args: Array[String]) {
      var a = 10;
      var b = 20;
      println("a == b = " + (a == b) );
      println("a != b = " + (a != b) );
      println("a > b = " + (a > b) );
      println("a < b = " + (a < b) );
      println("b >= a = " + (b >= a) );
      println("b <= a = " + (b <= a) );
   }
}

Implementação do código acima, a saída é:

$ scalac Test.scala 
$ scala Test
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

Operadores lógicos

A tabela a seguir lista o Scala suporta operadores lógicos.

Uma variável assumida como 1, B é 0:

Exemplos

object Test {
   def main(args: Array[String]) {
      var a = true;
      var b = false;

      println("a && b = " + (a&&b) );

      println("a || b = " + (a||b) );

      println("!(a && b) = " + !(a && b) );
   }
} 

Implementação do código acima, a saída é:

$ scalac Test.scala 
$ scala Test
a && b = false
a || b = true
!(a && b) = true

Operadores bit a bit

Operadores bit a bit bits usados ​​para operar, ~, &, |, ^ foram negados, eo bit, ou por pouco e, bit a bit operação XOR com os seguintes exemplos de mesa:

Se A = 60; e B = 13; duas variáveis ​​correspondente ao binário é:

A = 0011 1100

B = 0000 1101

-------位运算----------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

A regra Scala bit a bit como segue:

Exemplos

object Test {
   def main(args: Array[String]) {
      var a = 60;           /* 60 = 0011 1100 */  
      var b = 13;           /* 13 = 0000 1101 */
      var c = 0;

      c = a & b;            /* 12 = 0000 1100 */ 
      println("a & b = " + c );

      c = a | b;            /* 61 = 0011 1101 */
      println("a | b = " + c );

      c = a ^ b;            /* 49 = 0011 0001 */
      println("a ^ b = " + c );

      c = ~a;               /* -61 = 1100 0011 */
      println("~a = " + c );

      c = a << 2;           /* 240 = 1111 0000 */
      println("a << 2 = " + c );

      c = a >> 2;           /* 215 = 1111 */
      println("a >> 2  = " + c );

      c = a >>> 2;          /* 215 = 0000 1111 */
      println("a >>> 2 = " + c );
   }
} 

Implementação do código acima, a saída é:

$ scalac Test.scala 
$ scala Test
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2  = 15
a >>> 2 = 15

Operadores de atribuição

As listas a seguir o operador Scala linguagem atribuição de apoio:

Exemplos

object Test {
   def main(args: Array[String]) {
      var a = 10;	
      var b = 20;
      var c = 0;

      c = a + b;
      println("c = a + b  = " + c );

      c += a ;
      println("c += a  = " + c );

      c -= a ;
      println("c -= a = " + c );

      c *= a ;
      println("c *= a = " + c );

      a = 10;
      c = 15;
      c /= a ;
      println("c /= a  = " + c );

      a = 10;
      c = 15;
      c %= a ;
      println("c %= a  = " + c );

      c <<= 2 ;
      println("c <<= 2  = " + c );

      c >>= 2 ;
      println("c >>= 2  = " + c );

      c >>= 2 ;
      println("c >>= a  = " + c );

      c &= a ;
      println("c &= 2  = " + c );
     
      c ^= a ;
      println("c ^= a  = " + c );

      c |= a ;
      println("c |= a  = " + c );
   }
} 

Implementação do código acima, a saída é:

$ scalac Test.scala 
$ scala Test
c = a + b  = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a  = 1
c %= a  = 5
c <<= 2  = 20
c >>= 2  = 5
c >>= a  = 1
c &= 2  = 0
c ^= a  = 10
c |= a  = 10

Precedência de operador

Em uma expressão pode conter uma pluralidade de diferentes operadores de ligação com diferentes tipos de dados de objectos de dados, uma vez que a expressão tem uma variedade de operações, uma ordem diferente de operações podem ter diferentes resultados, mesmo errada erro de operação, porque quando quando uma expressão contendo uma variedade de operações, de acordo com uma certa ordem devem ser combinadas de modo a assegurar a racionalidade e exactidão dos resultados, a singularidade da operação.

Prioridade por ordem decrescente de cima para baixo, a parte superior tem a maior prioridade, o operador vírgula tem a prioridade mais baixa.

O mesmo nível de prioridade, de acordo com a ordem de ligação de cálculo. A maioria das operações são calculados a partir da esquerda para a direita, apenas três prioridades são da direita para a esquerda combinação, eles são operadores unários, operadores condicionais, operadores de atribuição.

As prioridades básicas precisa se lembrar:

• ponteiro ideal, unário de operadores binários. Como o sinal.
• Primeiro multiplicação e divisão (módulo) após subtracção.
• Primeira operação de deslocamento aritmético após a última computação pouco. Por favor, preste especial atenção: << 1 2 & 3 + 7 é equivalente a (1 << (3 + 2)) e 7
• operação final lógica de cálculo