第 3 章 运算符

Scala 运算符的使用和 Java 运算符的使用基本相同，只有个别细节上不同。

3.1 算术运算符

1）基本语法

运算符 运算 范例 结果
+ 正号 +3 3
- 负号 b=4; -b -4
+ 加 5+5 10
- 减 6-4 2
* 乘 3*4 12
/ 除 5/5 1
% 取模(取余) 7%5 2
+ 字符串相加 “hel”+”lo” “hello”

  • 对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。

  • 对一个数取模 a%b，和 Java 的取模规则一样.

2）案例实操

1
2
3
4
5
6
7
8
9
10
11
12
// 1. 算术运算符
val result1: Int = 10 / 3
println(result1)

val result2: Double = 10 / 3
println(result2)

val result3: Double = 10.0 / 3
println(result3.formatted("%5.2f"))

val result4: Int = 10 % 3
println(result4)

image-20210330232424210

3.2关系运算符（比较运算符）

1）基本语法

运算符 运算 范例 结果
== 相等于 4==3 false
!= 不等于 4！=3 true
< 小于 4<3 false
> 大于 4>3 true
<= 小于等于 4<=3 false
>= 大于等于 4>=3 true

2）案例实操

  • 需求: Java 和 Scala 中关于==的区别
    • Java： ==比较两个变量本身的值，即两个对象在内存中的首地址；equals 比较字符串中所包含的内容是否相同。
    • Scala：==更加类似于 Java 中的 equals，参照 jd 工具
1
2
3
4
5
6
val s1: String = "hello"
val s2: String = new String("hello")

println(s1 == s2)      // true 
println(s1.equals(s2)) // true 
println(s1.eq(s2))     // false

3.3 逻辑运算符

1）基本语法

用于连接多个条件（一般来讲就是关系表达式），最终的结果也是一个 Boolean 值。

假定：变量 A 为 true，B 为 false

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

2）案例实操

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// 3. 逻辑运算符
def m(n: Int): Int = {
  println("m被调用")
  return n
}

val n = 1
println((4 > 5) && m(n) > 0)

// 判断一个字符串是否为空 
// 扩展避免逻辑与空指针异常 
def isNotEmpty(str: String): Boolean = {
  return str != null && !("".equals(str.trim))
}

println(isNotEmpty(null))

3.4 赋值运算符

1）基本语法

赋值运算符就是将某个运算后的值，赋给指定的变量。

运算符 描述 实例
= 简单的赋值运算符，将一个表达式的值赋给一个左值 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

注意：Scala 中没有++、–操作符，可以通过+=、-=来实现同样的效果；

2）案例实操

1
2
3
4
5
6
7
8
9

// 4. 赋值运算符
var b: Byte = 10
b += 1   // error +=1 默认是Int类型

var i: Int = 12
i += 1
println(i) //13

3.5 位运算符

1）基本语法

下表中变量 a 为 60，b 为 13。

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

2）案例实操

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
    // 5. 位运算符
    val a: Byte = 60
    println(a << 3)
    println(a >> 2)
    println(a >>> 2)

60的是Byte类型 位运算操作Byte的最大值会转换为Int
原码：0011 1100
补码：0011 1100
左移三位：0000 0001 1110 0000 低位补0
右移两位：0000 1111   正数无符号右移和有符号右移都是 高位补0所以都一样。


    val b: Short = -13
    println(b << 2)
    println(b >> 2)
    println(b >>> 2)

-13的  （short 2个字节 原码应该是 1000 0000 0000 1101 补码为1111 1111 1111 0011） 因为结果一样这里就截取后八位运算了

原码为0000 1101   
补码为1111 0011
补码左移两位： 1100 1100 
对应原码：0011 0100 即为 -52

补码有符号右移两位  1111 1100  左边补也是补符号位 如果是负数就是补1 不会改变正负值
对应原码：0000 0011  即为 -4  （直接移出去就相当于截取整数部分，然后又是补码表达，就是向下取整，所以这里-3.几直接就取-4）


无符号右移就直接 最前面补0，然后因为之前-13最前面全是1，移动之后最前面补2个0，就是一个很大的正数。

image-20210330235539400

3.6 Scala 运算符本质

在 Scala 中其实是没有运算符的，所有运算符都是方法。

  • 当调用对象的方法时，点.可以省略

  • 如果函数参数只有一个，或者没有参数，()可以省略

1
2
3
4
5
6
7
8
9
10
11
    // 6. 运算符的本质
    val n1: Int = 12
    val n2: Int = 37

    println(n1.+(n2))
    println(n1 + n2 )

    println(1.34.*(25))
    println(1.34 * 25)

//    println(7.5 toInt toString)