Scala 运算符
运算符
运算符是一个符号,告诉编译器执行特定的数学或逻辑操作。Scala具有丰富的内置运算符,并提供以下类型的运算符-
- 算术运算符
- 关系运算符
- 逻辑运算符
- 按位运算符
- 赋值运算符
本章将逐一研究算术,关系,逻辑,按位,赋值和其他运算符。
算术运算符
Scala语言支持以下算术运算符。例如,假设变量A持有10,变量B持有20,则-
运算符 | 描述 | 例子 |
---|---|---|
+ | 加两个操作数 | A + B得30 |
– | 从第一个减去第二个操作数 | A – B得-10 |
* | 将两个操作数相乘 | A * B得200 |
/ | 将分子除以除分子 | B / A得2 |
% | 模运算符将一个数除以另一个后得到余数 | B %A得0 |
*示例:**
object Demo {
def main(args: Array[String]):Unit= {
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) );
}
}
输出:
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
关系运算符
Scala语言支持以下关系运算符。例如,假设变量A持有10,变量B持有20,则-
运算符 | 描述 | 例子 |
---|---|---|
== | 检查两个操作数的值是否相等,如果是,则条件为true。 | (A == B)为false。 |
!= | 检查两个操作数的值是否相等,如果值不相等,则条件为true。 | (A != B)为true。 |
> | 检查左操作数的值是否大于右操作数的值,如果是,则条件为true。 | (A > B)为false。 |
< | 检查左操作数的值是否小于右操作数的值,如果是,则条件为true。 | (A < B)为true。 |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是,则条件为true。 | (A> = B)为false。 |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是,则条件为true。 | (A <= B)为true。 |
示例:
object Demo {
def main(args: Array[String]):Unit= {
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) );
}
}
输出:
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false
逻辑运算符
Scala语言支持以下逻辑运算符。例如,假设变量A持有1,变量B持有0,则-
运算符 | 描述 | 例子 |
---|---|---|
&& | 它称为逻辑与运算符。如果两个操作数都不为零(false),则条件为true。 | (A && B)为false。 |
|| | 它称为逻辑或运算符。如果两个操作数中的任何一个不为零(false),则条件为真。 | (A || B)为true。 |
! | 它称为逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为真,则逻辑非运算符将为假。 | !(A && B) 为true。 |
示例:
object Demo {
def main(args: Array[String]):Unit = {
var a = true;
var b = false;
println("a && b = " + (a&&b) );
println("a || b = " + (a||b) );
println("!(a && b) = " + !(a && b) );
}
}
输出:
a && b = false
a || b = true
!(a && b) = true
按位运算符
按位运算符对位进行运算并逐位执行操作。&,|和^的真值表如下-
p | q | p&q | p|q | p^q |
---|---|---|---|---|
0 | 0 | 0 | 0 | 0 |
0 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 |
1 | 0 | 0 | 1 | 1 |
假设A = 60; 和B = 13; 现在以二进制格式,它们将如下所示-
A = 0011 1100
B = 0000 1101
-----------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
示例:下表列出了Scala语言支持的按位运算符。假设变量A为60,变量B为13,则-
运算符 | 描述 | 例子 |
---|---|---|
& | 如果两个操作数中对应位都存在,则会将一位复制到结果中。 | (A&B)将得到12,即0000 1100 |
| | 如果任一操作数中存在,则会对其进行复制。 | (A | B)将得到61,即0011 1101 |
^ | 如果在一个操作数中设置了该位,但不是在两个操作数中都设置了位,则二进制异或运算符将复制该位。 | (A ^ B)将得出49,即0011 0001 |
~ | 二进制补码运算符是一元的,具有“翻转”位的作用。 | (~A)将给出-61,这是2的补码形式的1100 0011(由于带符号的二进制数)。 |
<< | 二进制左移运算符。左操作数值的位位置向左移动右操作数指定的位数。 | A << 2 将得到240,即1111 0000 |
>> | 二进制右移运算符。左操作数值的位位置向右移动右操作数指定的位数。 | A >> 2 将得到15,即1111 |
>>> | 右移零填充运算符。左操作数的值向右移动右操作数指定的位数,并且移位后的值用零填充。 | A >>> 2将得到15,即0000 1111 |
object Demo {
def main(args: Array[String]):Unit = {
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 );
}
}
输出:
a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15
a >>> 2 = 15
赋值运算符
Scala语言支持以下赋值运算符-
运算符 | 描述 | 例子 |
---|---|---|
= | 简单的赋值运算符,将值从右侧操作数分配到左侧操作数 | C = A + B将A + B的值赋给C |
+= | 加和赋值运算符,将右操作数添加到左操作数,并将结果分配给左操作数 | C += A等于C = C + A |
-= | 减和赋值运算符,它从左操作数中减去右操作数,并将结果分配给左操作数 | C -= A等于C = C-A |
*= | 乘和赋值运算符相乘,将右操作数与左操作数相乘并将结果分配给左操作数 | C *= A等效于C = C * A |
/= | 除和赋值运算符,它将左操作数除以右操作数,并将结果分配给左操作数 | C /= A等于C = C / A |
%= | 模和赋值运算符,使用两个操作数取模并将结果分配给左操作数 | C %= A等于C = C%A |
<<= | 左移和赋值运算符 | C <<= 2与C = C << 2相同 |
>>= | 右移和赋值运算符 | C >>= 2与C = C >> 2相同 |
&= | 按位与和赋值运算符 | C &= 2与C = C&2相同 |
^= | 按位异或和赋值运算符 | C ^= 2与C = C ^ 2相同 |
|= | 按位或运算符和赋值运算符 | C |= 2等于C = C | 2 |
示例:
object Demo {
def main(args: Array[String]):Unit = {
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 >>= 2 = " + c );
c &= a ;
println("c &= a = " + c );
c ^= a ;
println("c ^= a = " + c );
c |= a ;
println("c |= a = " + c );
}
}
输出:
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 >>= 2 = 1
c &= a = 0
c ^= a = 10
c |= a = 10
Scala中的运算符优先级
运算符优先级确定表达式中术语的分组。这会影响表达式的求值方式。某些运算符具有更高的优先级;例如,乘法运算符的优先级比加法运算符高-例如,x = 7 + 3 * 2; 在这里,x被赋值为13,而不是20,因为运算符*的优先级比+高,因此它首先与3 * 2相乘,然后加到7。看看下表。优先级最高的运算符出现在表格的顶部,优先级最低的运算符出现在表格的底部。在表达式中,优先级较高的运算符将首先被计算。
类别 | 操作符 | 关联性 |
---|---|---|
后缀 | () [] | 左到右 |
一元 | ! ~ | 右到左 |
乘性 | * / % | 左到右 |
加减 | + – | 左到右 |
位移 | >> >>> << | 左到右 |
关系型 | > >= < <= | 左到右 |
平等 | == != | 左到右 |
按位与 | & | 左到右 |
按位异或 | ^ | 左到右 |
按位或 | | | 左到右 |
逻辑与 | && | 左到右 |
逻辑或 | || | 左到右 |
分配 | = += -= *= /= %= >>= <<= &= ^= |= | 右到左 |
逗号 | , | 左到右 |