opérateur Scala

Un opérateur est un symbole, utilisé pour indiquer au compilateur d'effectuer une des opérations mathématiques et logiques spécifiques.

Scala riches opérateurs intégrés, y compris les types suivants:

• Les opérateurs arithmétiques

• opérateurs relationnels

• opérateurs logiques

• opérateurs sur les bits

• Opérateurs d'affectation

Ensuite, nous allons vous expliquer plus que l'application des différents opérateurs.

Les opérateurs arithmétiques

Le tableau suivant répertorie les opérateurs arithmétiques support Scala.

Une variable suppose que 10, B 20:

Exemples

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) );
      
   }
}

Exécution instance »

Mise en œuvre du code ci-dessus, la sortie est:

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

opérateurs relationnels

Le tableau suivant dresse la liste Scala supporte les opérateurs relationnels.

Une variable suppose que 10, B 20:

Exemples

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) );
   }
}

Mise en œuvre du code ci-dessus, la sortie est:

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

opérateurs logiques

Le tableau suivant dresse la liste Scala prend en charge des opérateurs logiques.

Une variable supposé que 1, B est 0:

Exemples

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) );
   }
} 

Mise en œuvre du code ci-dessus, la sortie est:

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

opérateurs sur les bits

Opérateurs binaires de bits utilisés pour faire fonctionner, ~, &, |, ^ ont été annulés, et le bit, ou à peu et, au niveau du bit opération XOR avec les exemples de tableau suivant:

Si A = 60 et B = 13; deux variables correspondant au binaire est:

A = 0011 1100

B = 0000 1101

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

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

La règle Scala Bitwise comme suit:

Exemples

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 );
   }
} 

Mise en œuvre du code ci-dessus, la sortie est:

$ 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

Opérateurs d'affectation

Les listes suivantes l'opérateur Scala d'affectation de support de la langue:

Exemples

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 );
   }
} 

Mise en œuvre du code ci-dessus, la sortie est:

$ 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

Préséance de l'opérateur

Dans une expression peut contenir une pluralité de différents opérateurs de connexion avec différents types d'objets de données de données, puisque l'expression a une variété d'opérations, un ordre différent des opérations peut avoir des résultats différents, même erronée erreur d'opération, parce que quand quand une expression contenant une variété d'opérations, selon un certain ordre doit être combiné afin d'assurer la rationalité et l'exactitude des résultats, le caractère unique de l'opération.

Priorité dans l'ordre décroissant de haut en bas, en haut a la plus haute priorité, l'opérateur virgule a la priorité la plus basse.

Le même niveau de priorité, selon l'ordre de liaison de calcul. La plupart des opérations sont calculées à partir de gauche à droite, seuls trois priorités sont de droite à gauche combinaison, ils sont des opérateurs unaires, opérateurs conditionnels, des opérateurs d'affectation.

Les priorités de base doivent se rappeler:

• pointeur Optimal, unaire que les opérateurs binaires. Comme le signe.
• Première multiplication et la division (module) après soustraction.
• Première opération de décalage arithmétique après le dernier bit informatique. S'il vous plaît prêter une attention particulière à: << 1 2 & 3 + 7 est équivalent à (1 << (3 + 2)) et 7
• opération finale de logique de calcul