Scala——运算符、流程控制

3 运算符

3.1 算术运算符

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

package com.yu.chapter03

object TestArithmetic {
  def main(args: Array[String]): Unit = {
    //对于除号/，整数之间做除法只保留整数部分
    var r1: Int = 10 / 3
    println("r1=" + r1)  //r1=3

    var r2: Double = 10 / 3
    println("r2=" + r2)  //r2=3.0
    //在做完整数除之后再转换为Double类型，3->3.0  可以使用10.3/3

    var r3:Double = 10.0 / 3 // 3.33333
    println("r3=" + r3)
    println("r3=" + r3.formatted("%5.2f"))
    //r3=3.3333333333333335
    //r3= 3.33  共五位，保留两位小数
  }
}

3.2 关系运算符

Java和Scala中关于==的区别：
Java：==比较两个变量本身的值，即两个对象在内存中的地址；equals比较字符串中所包含的内容是否相同。
Scala：==更加类似于Java中的equals，比较的是内容是否相同。

package com.yu.chapter03

object TestRelation {
  def main(args: Array[String]): Unit = {
    var a : Int = 2
    var b : Int = 1
    println(a > b)
    println(a >= b)
    println(a <= b)
    println(a < b)
    println("a==b " + (a==b)) //a==bfalse
    println(a != b)
  }
}

3.3 逻辑运算符

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

3.4 赋值运算符

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

3.5 位运算符

假定变量a为60，b为13.

3.6 Scala运算符本质

在 Scala 中其实是没有运算符的，所有运算符都是方法。
1）当调用对象的方法时，点.可以省略
2）如果函数参数只有一个，或者没有参数，()可以省略

4 流程控制

4.1 分支控制if-else

让程序有选择的的执行，分支控制有三种：单分支、双分支、多分支

1. 单分支

if  (条件表达式) {
	执行代码块
}

2. 双分支

if  (条件表达式) {
	执行代码块1
} else {
	执行代码块2
}

3. 多分支

if  (条件表达式1) {
	执行代码块1
} 
else if (条件表达式2){
	执行代码块2
}
	…
else {
	执行代码块n
}

4.2 嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层。分支外面的分支结构称为外层分支。嵌套分支不要超过 3 层。

基本语法：

if (){
	if (){
	}else{
	}
}

4.3 Switch分支结构

在 Scala 中没有 Switch，而是使用模式匹配来处理。

4.4 For循环控制

1. 范围数据循环（To）

基本语法：

for (i <- 1 to 3){
	print(i + " ")
}
println()

（1）i 表示循环的变量，<- 规定 to
（2）i 将会从 1-3 循环，前后闭合

2. 范围数据循环（Util）

基本语法：

for (i <- 1 until 3){
	print(i + " ")
}
println()

（1）这种方式和前面的区别在于 i 是从 1 到 3-1
（2）即使前闭合后开的范围

3. 循环守卫

基本语法：

for (i <- 1 to 3 if i != 2){
	print(i + " ")
}
println()

循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为 false 则跳过，类似于 continue。

4. 循环步长

基本语法：

for (i <- 1 to 3 by 2){
	print(i + " ")
}
println()

by表示步长，即1，3

5. 嵌套循环

基本语法：

for (i <- 1 to 3; j <- 1 to 3){
	println("i = " + i + " j =  " + j)
}

说明：没有关键字，所以范围后一定要加；来隔断逻辑

6. 引入变量

基本语法：

for (i <- 1 to 3; j = 4 - i){
	println("i = " + i + " j =  " + j)
}

（1）for 推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑
（2）for 推导式有一个不成文的约定：当 for 推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下

for {
	i <- 1 to 3
	j = 4-i
} {
	println("i = " + i + " j =  " + j)
}

7. 循环返回值

基本语法：

val res = for (i <- 1 to 10) yield i
println(res)

说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。输出的是一个集合。
注意：开发中很少使用。
8. 倒序打印reverse

for (i <- 1 to 10 reverse){
	println(i)
}

4.5 While 和 do…While循环控制

1. While循环控制

基本语法：

while(循环条件){
	循环体（语句）
	循环变量迭代	
}

（1）循环条件是返回一个布尔值的表达式
（2）while 循环是先判断再执行语句
（3）与 for 语句不同，while 语句没有返回值，即整个 while 语句的结果是 Unit 类型()
（4）因为 while 中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在 while 循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用 for 循环。

var i = 0
while (i < 10){
	println("love" + i)
	i += 1
}

2. do…while循环控制
   基本语法：

循环变量初始化；
do {
	循环体(语句)
	循环变量迭代
} while(循环条件)

（1）循环条件是返回一个布尔值的表达式
（2）do…while 循环是先执行，再判断

var i = 0
do {
	println("love" + i)
	i += 1
} while (i < 10)

4.6 循环中断

Scala 内置控制结构特地去掉了 break 和 continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。Scala中使用breakable控制结构来实现 break 和 continue 功能。

（1）采用异常的方式退出循环

try {
	for (ele <- 1 to 10) {
		println(elem)
		if (elem == 5) throw new RuntimeException
		} 
	} catch {
		case e =>
	}
	println("结束循环")

（2）采用Scala自带的函数，退出循环

Breaks.breakable(
	for (elem <- 1 to 10) {
		println(elem)
		if (elem == 5) Breaks.break()
	}
)

引入Breaks._包，可以省略Breaks

4.7 多重循环

（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过 3 层】
（2）设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

//九九乘法表打印
for (i <- 1 to 9) {
	for (j <- 1 to i) {
		print(j + "*" + i + "=" + (i * j) + "\t")
	}
	println()
}