算术运算符
1.短路是指什么意思？
2.scala中如何判断相等？
3.scala中有自增和自减吗？
4.&& 和 || 哪个的优先级高？
5.scala中如何处理浮点数的精度问题？
（一）运算符概述
运算符就一个特殊的符号，使用运算符可以将一个或多个操作数连成可执行的语句，用于实现不同的功能。
按照对数据操作的功能不同，我们可以把Scala运算符分为以下五大类。
· 算术运算符：只能用来做加、减、乘、除等算术运算。
· 关系运算符：用来对数值进行比较，比如>、<=、>=等。
· 逻辑运算符：包含逻辑与、逻辑或、逻辑非三种运算符，也是用于比较的。
· 位运算符：用于对二进制数的位进行左移、右移、取反等操作。
· 赋值运算符：用于将一个值进行赋值，例如=、+=、-=等。
（二）Scala的算术运算符
//算术运算符
//数据类型 7：Int
// 4：Int
// 7/4的结果是Int
println(7/4)
println(7%4)
println(7-4)
println(7+4)
println(7*4)
Scala中算术运算的本质总结如下：
· +相当于调用对应类型的+方法
· -相当于调用对应类型的-方法
· 相当于调用对应类型的方法
· /相当于调用对应类型的/方法
· %相当于调用对应类型的%方法
注：重点提示：7/4=1。
（三）Scala的关系运算符
关系运算符会得到Bool值。scala中的关系运算符如下：
== 等于
!= 不等于
》 大于
< 小于
》= 大于等于
<= 小于等于
//关系运算符< > >= <= == !=
//false ture
val a:Boolean = 3 > 2
println(7==4)//false
println(7>4)//ture
println(7!=4)//ture
println(7<4)//false
println(7>=4)//ture
println(7<=4)//false
（四）Scala的逻辑运算符
Scala中的逻辑运算跟Java中一样，也是与、或、非三种情况，具体如下。
· 与：&& 运算表达式有一个为假，则整个表达式为假false。
· 或：|| 运算表达式有一个为真，则整个表达式为真true。
非：! 就是取反的意思，与参与表达式相反。
//逻辑运算符
/*
&&（并且）全部为true ===> true
||（或者）只有一个为true ===> true
！（取反）
*/
println( 3 > 3 && 3 > 4 )//false
println( 2 > 3 && 4 > 3 )//false
println( 1 > 2 && 2 > 1 )//false
println( 3 < 5 || 5 > 3 )//true
println( !(3>5) )//true
例如判断闰年如下图所示
代码
// 判断闰年
/*
1. 让用户输入一个整数，表示年份
2. 判断这个年份是否是闰年
3. 输出结果
*/
println("请输入一个年份：")
val year: Int = scala.io.StdIn.readLine().toInt
// 闰年判断规则：
// 1. 能被4整除但不能被100整除的是闰年
// 2. 能被400整除的是闰年
val result: Boolean =
if (year % 400 == 0) true
else if (year % 100 == 0) false
else year % 4 == 0
if (result) {
println(s"$year 是闰年")
} else {
println(s"$year 不是闰年")
}
（六）Scala的赋值运算符
= 简单的赋值运算，指定将右边操作数赋值给左边的操作数
+= 相加后再赋值，将左右两边的操作数相加后再赋值给左边的操作数
-= 相减后再赋值，将左右两边的操作数相减后再赋值给左边的操作数
*= 相乘后再赋值，将左右两边的操作数相乘后再赋值给左边的操作数
/= 相除后再赋值，将左右两边的操作数相除后再赋值给左边的操作数
%= 求余后再赋值，将左右两边的操作数进行求余操作后再赋值给左边的操作数
例如
// 赋值运算符
var a = 1 // 把右边的计算结果保存到左边的变量
println(s"初始值: a = $a")
a += 2 // a += 2 等价于 a = a + 2
println(s"a += 2 后: a = $a") // 输出: 3
a -= 3 // a -= 3 等价于 a = a - 3
println(s"a -= 3 后: a = $a") // 输出: 0
a += 4 // 先加4，避免除0错误
println(s"a += 4 后: a = $a") // 输出: 4
a /= 2 // a /= 2 等价于 a = a / 2
println(s"a /= 2 后: a = $a") // 输出: 2
a *= 5 // a *= 5 等价于 a = a * 5
println(s"a *= 5 后: a = $a") // 输出: 10
// 其他赋值运算符示例
a %= 3 // a %= 3 等价于 a = a % 3
println(s"a %= 3 后: a = $a") // 输出: 1
（七）Scala的位运算符
常用的位运算符如下：
1. & 按位与运算符。0&1 = 0, 1&0= 0 , 0&0 = 0, 1&1 = 1
2. | 按位或运算符。0|1 = 1, 1|0= 1 , 0|0 = 0, 1|1 = 1
3. ^ 按位异或运算符。0^1 = 1, 1^1= 0, 0^0 = 0
4. ~ 按位取反运算符
5. << 左移运算符。右边补零，放大。
6. >> 右移运算符。左边补零，缩小。
// 位运算
println(5 & 4) // 按位与：5(101) & 4(100) = 4(100)
println(5 | 4) // 按位或：5(101) | 4(100) = 5(101)
println(4 << 2) // 左移2位：4(100) << 2 = 16(10000)
println(4 >> 2) // 右移2位：4(100) >> 2 = 1(1)
println(5 ^ 4) // 按位异或：5(101) ^ 4(100) = 1(001)
println(~5) // 按位取反：~5 = -6
（八）Scala中运算符的优先级
1. 乘(*)除(/)模(%) > 加(+)减(-)
2. 算术(+-*/%) > 关系(><>=!=) > 赋值(=)
3. && > ||
val result = 10 - 2 + 3 * 4 / 2
println(result) // 问题1
val a = true
val b = false
val c = false
println(a || b && c) // 问题2
（九）浮点数精度问题
解释：由于精度的问题，小数的计算会存在误差。
0.1 + 0.2 == 0.3 // false
解决方案：使用BigDecimal()函数。
println(0.1 + 0.2 == 0.3)
println(BigDecimal(0.1) + BigDecimal(0.2) == BigDecimal(0.3))
