Scala Operators

Example

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

When the above code is executed, the output result is:

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

Logical operators

The following table lists the logical operators supported by Scala.

Assuming the variable A is 1, B is 0:

Online Example

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

When the above code is executed, the output result is:

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

Bitwise operators

Bitwise operators are used to operate on binary bits, ~, & , |, ^ respectively represent bitwise NOT, bitwise AND, bitwise OR, and bitwise XOR operations, as shown in the following examples:

If A is specified = 60; and B = 13; The binary representation of the two variables is as follows:

A　=　0011　1100
B　=　0000　1101
-------Bitwise operation----------
A&B　=　0000　1100
A|B　=　0011　1101
A^B　=　0011　0001
~A　　=　1100 0011

The bitwise operation rules in Scala are as follows:

Online Example

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;　　　　　　　　　　　/*　15　=　1111　*/
　　　　　　println("a >>"　2　　=　+　c　);
　　　　　　c = a >>>　2;　　　　　　　　　　/*　15　= 0000　1111　*/
　　　　　　println("a >>>"　2　=　+　c　);
　　　}
}

When the above code is executed, the output result is:

$　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

Assignment operators

The following lists the assignment operators supported by the Scala language:

Online Example

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　>>=　a　;
　　　　　　println("c　>>=　a　　=　"　+　c　);
　　　　　　c　&=　a　;
　　　　　　println("c　&=　2　　=　+　c　);
　　　　　
　　　　　　c　^=　a　;
　　　　　　println("c　^=　a　　=　"　+　c　);
　　　　　　c　|=　a　;
　　　　　　println("c　|=　a　　=　"　+　c　);
　　　}
}

When the above code is executed, the output result is:

$　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　　=　0
c　&=　2　　=　0
c　^=　a　　=　10
c　|=　a　　=　10

The precedence of operators depends on the operator group they belong to, which affects the calculation of the expression.

Example: x = 7 + 3 * 2; Here, the calculation result of x is 13), not 20, because multiplication (*), which is higher than addition (+), so it calculates first 3*2 In addition to 7.

See the following table, the priority decreases from top to bottom, the topmost has the highest priority, and the comma operator has the lowest priority.