Scala 运算符

Scala 运算符

云算法可以告诉编译器来执行指定的数学运算和逻辑运算。

1、丰富的内置运算符

• 算术运算符

• 关系运算符

• 逻辑运算符

• 位运算符

• 赋值运算符

2、算术运算符

下面列出了 Scala 支持的算术运算符。

假定变量 X 为 8，Y 为 2：

运算符	描述	实例
+	加号	X + Y 运算结果为 10
-	减号	X - Y 运算结果为 6
*	乘号	X * Y 运算结果为 16
/	除号	Y / X 运算结果为 4
%	取余	Y % X 运算结果为 0

 

object Demo {
   def main(args: Array[String]) {
      var x = 100;
      var y = 200;
      var z = 50;
      println("x + y = " + (x + y) );
      println("x - y = " + (x - y) );
      println("x * y = " + (x * y) );
      println("y / x = " + (y / x) );
      println("y % x = " + (y % x) );
      println("z % x = " + (z % x) );
   }
}

3、关系运算符

下面列出了 Scala 支持的关系运算符。

假定变量 X 为 5，Y 为 10：

运算符	描述	实例
==	等于	(X == Y) 运算结果为 false
!=	不等于	(X != Y) 运算结果为 true
>	大于	(X > Y) 运算结果为 false
<	小于	(X < Y) 运算结果为 true
>=	大于等于	(X >= Y) 运算结果为 false
<=	小于等于	(X <= Y) 运算结果为 true

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

4、逻辑运算符

下面列出了 Scala 支持的逻辑运算符。

假定变量 X 为 1，Y 为 0：

运算符	描述	实例
&&	逻辑与	(X && Y) 运算结果为 false
||	逻辑或	(X || Y) 运算结果为 true
!	逻辑非	!(X && Y) 运算结果为 true

object Demo {
   def main(args: Array[String]) {
      var x = true;
      var y = false;
      println("x && y = " + (x&&y) );
      println("x || y = " + (x||y) );
      println("!(x && y) = " + !(x && y) );
   }
}

 5、位运算符

位运算符用来对二进制位进行操作，~,&,|,^ 分别为取反，按位与与，按位与或，按位与异或运算，比如：

x	y	x & y	x | y	x ^ y
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

如果指定 X = 60; 及 Y = 13; 两个变量对应的二进制为：

X = 0011 1100

Y = 0000 1101

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

X&Y = 0000 1100

X|Y = 0011 1101

X^Y = 0011 0001

~X  = 1100 0011

 

Scala 中的按位运算法则如下：

运算符	描述	实例
&	按位与运算符	(x & y) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符	(x | y) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符	(x ^ y) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符	(~x ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<<	左移动运算符	x << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符	x >> 2 输出结果 15 ，二进制解释： 0000 1111
>>>	无符号右移	x >>>2 输出结果 15, 二进制解释: 0000 1111

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

      c = x & y;            /* 12 = 0000 1100 */
      println("x & y = " + c );

      c = x | y;            /* 61 = 0011 1101 */
      println("x | y = " + c );

      c = x ^ y;            /* 49 = 0011 0001 */
      println("x ^ y = " + c );

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

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

      c = x >> 2;           /* 15 = 1111 */
      println("x >> 2  = " + c );

      c = x >>> 2;          /* 15 = 0000 1111 */
      println("x >>> 2 = " + c );
   }
}

6、赋值运算符

下面列出了 Scala 语言支持的赋值运算符：

运算符	描述	实例
=	简单的赋值运算，指定右边操作数赋值给左边的操作数。	Z = X + Y 将 X + Y 的运算结果赋值给 Z
+=	相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数。	Z += X 相当于 Z = Z + X
-=	相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数。	Z -= X 相当于 Z= Z - X
*=	相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数。	Z *= X 相当于 C = Z * X
/=	相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数。	Z /= X 相当于 C = C / X
%=	求余后再赋值，将左右两边的操作数求余后再赋值给左边的操作数。	Z %= X is equivalent to Z = Z % X
<<=	按位左移后再赋值	Z <<= 2 相当于 Z = Z << 2
>>=	按位右移后再赋值	Z >>= 2 相当于 Z = Z >> 2
&=	按位与运算后赋值	Z &= 2 相当于 Z = Z & 2
^=	按位异或运算符后再赋值	Z ^= 2 相当于 Z = Z ^ 2
|=	按位或运算后再赋值	Z |= 2 相当于 Z = Z | 2

object Demo {
   def main(args: Array[String]) {
      var x = 10;      
      var y = 20;
      var z = 0;

      z = x + y;
      println("z = x + y  = " + z );

      z += x ;
      println("z += x  = " + z );

      z -= x ;
      println("z -= x = " + z );

      z *= x ;
      println("z *= x = " + z );

      x = 10;
      z = 15;
      z /= x ;
      println("z /= x  = " + z );

      x = 10;
      z = 15;
      z %= x ;
      println("z %= x  = " + z );

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

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

      z >>= x ;
      println("z >>= x  = " + z );

      z &= x ;
      println("z &= 2  = " + z );
     
      z ^= x ;
      println("z ^= x  = " + z );

      z |= x ;
      println("z |= x  = " + z );
   }
}

7、运算符优先级

运算符优先级取决于所属的运算符组，它会影响算式的的计算。

实例： x = 8 + 4 * 3; 这里， x 计算结果为 20, 而不是 36，因为乘法（*） 高于加法（+）, 所以它先计算 4*3再加上 8。

类别	运算符	关联性
1	() []	左到右
2	! ~	右到左
3	* / %	左到右
4	+ -	左到右
5	>> >>> <<	左到右
6	> >= < <=	左到右
7	== !=	左到右
8	&	左到右
9	^	左到右
10	|	左到右
11	&&	左到右
12	||	左到右
13	= += -= *= /= %= >>= <<= &= ^= |=	右到左
14	,	左到右