【scala专栏_持续更新】13_scala流程控制语句

【大纲】

【正文】

1.【结论】顺序结构

0.顺序结构
    程序按从上到下，从左到由的顺序，依次执行。中间没有任何判断和跳转
    
1.顺序结构是Scala代码默认流程控制结构

示例

scala> val a = 10
a: Int = 10

scala> println("a:" + a)
a:10

scala> println("hello")
hello

scala> println(1 + 1 + "hello" + 2 + 3)
2hello23

2.【结论】if语句

# 注意：
    0.在scala中，没有三元表达式，使用if表达式替代三元表达式
    1.if语句可嵌套，嵌套一般不要超过3层

2.1.【结论】单分支

if(关系表达式){
    代码块
}

示例

scala> if(3 > 2){println("hello")}
hello

2.2.【结论】双分支

if(关系表达式) {
    代码块
} else {
    代码块
}

示例

scala> val a = if(3 > 2){3}else{2}
a: Int = 3

scala> val y = if(1 > 0) 1 else "error"
y: Any = 1

scala> val y = if(1 > 2) 1 else ()
y: AnyVal = ()

scala> val y = if(1 > 2) 1 # 说明：缺失else，相当于if(1 > 2) 1 else ()
y: AnyVal = ()

2.3.多分支

if(关系表达式1){
    代码块
}else if(关系表达式2){
    代码块
}else if(关系表达式n){
    代码块
}else{
    代码块
}

示例

scala> var score = 80
score: Int = 80

scala> if(score >= 90 && score <= 100) {
     |     println("a")
     | } else if(score >= 80 && score < 90) {
     |     println("b")
     | } else if(score >= 0 && score < 80) {
     |     println("c")
     | } else {
     |     println("d")
     | }
b

scala> val y = if (25 < 10) "level1" else if (25 >= 10 && 25 <= 20) "level2" else "level3"
y: String = level3

3.【结论】循环语句

# 注意：
    0.for、while、do-while语句中，优先使用for语句，语法简洁优雅

3.1.for循环

3.1.1.【结论】单层for

for(i <- 表达式/数组/集合){
    代码块
}

示例

scala> val a = 1 to 3
a: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3)

scala> for(i <- a)println(i)
1
2
3

# 下标方式，遍历数据
scala> val arr = Array("a", "b", "c")
arr: Array[String] = Array(a, b, c)

scala> for(i <- 0 to arr.length - 1) println(arr(i))
a
b
c

# 下标方式，遍历数据
scala> val arr = Array("a", "b", "c")
arr: Array[String] = Array(a, b, c)

scala> for(i <- 0 until arr.length) println(arr(i))
a
b
c

# 下标方式，遍历数组，步长为2
scala> for(i <- 0 until (arr.length, 2)) println(arr(i))
a
c

# 倒叙，遍历数组
scala> val arr = Array("a", "b", "c")
arr: Array[String] = Array(a, b, c)

scala> for(i <- arr.reverse) println(i)
c
b
a

3.1.2.【结论】双层for

示例

# 方式一
scala> for(i <- 1 to 3){
     |   for(j <- 1 to 5) if(j == 5) println("*") else print("*")
     | }
*****
*****
*****

# 方式二
scala> for(i <- 1 to 3; j <- 1 to 5) if(j == 5) println("*") else print("*")
*****
*****
*****

3.1.3.【结论】for守卫条件

for(i <- 表达式/数组/集合 if 表达式){
    满足if条件的才会进来
}

示例

scala> for(i <- 1 to 3 if i != 2) println("hello")
hello
hello

scala> for(i <- 1 to 3; j <- 1 to 5 if i==2 && j==3) println(s"${i}--${j}")
2--3

3.1.3.【结论】for推导式

0.for推导式
    scala中一切皆可有返回值。for循环，也可以有返回值
    在for循环体中，可以用yield表达式构建出一个集合，使用了yield的for表达式就是for推导式

1.语法
    val a = for(i <- 表达式/数组/集合){
        yield 对i的操作
    }
    
    # 效果：a接收的是，yield构建出的集合

示例

scala> val a = for(i <- 1 to 10) yield i * 10
a: scala.collection.immutable.IndexedSeq[Int] = Vector(10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

4.【结论】while循环

初始化条件
while(判断条件){
    循环体
    控制条件
}

示例

scala> var i = 1
i: Int = 1

scala> while(i <= 3){ println(i); i = i + 1}
1
2
3

5.【结论】do-while循环

初始化条件
do{
    循环体
    控制条件
}while(判断条件)

# 注意：
    0.do-while循环，先执行一次循环体，再判断条件是否成立，如成立，再进行一次循环
    1.for、while循环都是先判断条件是否成立，如果条件不成立，循环体一次都不执行
    2.scala中没有 ++ 和 ‐‐ ，用 += 1 和 ‐= 1 来替代

示例

scala> var a = 1
a: Int = 1

scala> do{ println(a); a = a + 1 }while(a <= 3)
1
2
3

6.【结论】break效果

0.作用
    break效果，是跳出整个循环
    scala中没有break关键字，是使用函数式风格break()来实现的break效果
    
1.语法 方式一

    import util.control.Breaks._
    breakable{ // 包裹住想跳出的代码段
        代码1
        if(条件判断){
            break() // 具体跳出位置
        }
        代码2，break后，代码2不执行
    }
    
2.语法 方式二

    import util.control.Breaks._
    val br = new Breaks 
    br.breakable{ // 包裹住想跳出的代码段
        代码1
        if(判断条件){
            br.break() //具体跳出位置
        }
        代码2，break后，代码2不执行
    }
    
3.break()的()可省略

示例

# break
object Break {
  def main(args: Array[String]): Unit = {
    import util.control.Breaks._
    breakable{
      for(i <- 1 to 5){
        if(i == 3){break()}
        println(i)
      }
    }
  }
  // 效果：1 2
}

7.【结论】continue效果

0.作用
    continue效果，是跳出当前循环，继续下次循环
    scala中没有continue关键字，是使用函数式风格break()来实现的continue效果

示例

# continue
object Continue {
  def main(args: Array[String]): Unit = {
    for(i <- 1 to 5){
      import scala.util.control.Breaks._
      breakable{
        if(i == 3){break()}
        println(i)
      }
    }
  }
  // 效果：1 2 4 5
}

# break + continue
object BreakAndContinue {
  def main(args: Array[String]): Unit = {
    import util.control.Breaks._
    breakable{
      for(i <- 1 to 5){
        breakable{
          if(i == 3){ break() }
          println(i + "@")
        }
        if(i == 4){  break() }
        println(i + "#")
      }
    }
  }
  // 效果：1@ 1# 2@ 2# 3# 4@
}

---

T.TODO

T.1.九九乘法表 – 双层for循环

需求

1*1=1
2*1=2	2*2=4
3*1=3	3*2=6	3*3=9
4*1=4	4*2=8	4*3=12	4*4=16
5*1=5	5*2=10	5*3=15	5*4=20	5*5=25
6*1=6	6*2=12	6*3=18	6*4=24	6*5=30	6*6=36
7*1=7	7*2=14	7*3=21	7*4=28	7*5=35	7*6=42	7*7=49
8*1=8	8*2=16	8*3=24	8*4=32	8*5=40	8*6=48	8*7=56	8*8=64
9*1=9	9*2=18	9*3=27	9*4=36	9*5=45	9*6=54	9*7=63	9*8=72	9*9=81

Java思维的scala实现

object WsyTest {
  def main(args: Array[String]): Unit ={
    for(i <- 1 to 9){
      for(j <- 1 to i){
       print(i +"*"+ j + "=" + i * j + (if(i == j) "\n" else "\t"))
      }
    }
  }
}

Scala思维实现

object WsyTest {
  def main(args: Array[String]): Unit ={
    for(i <- 1 to 9; j <- 1 to i){print(i +"*"+ j + "=" + i * j + (if(i==j)"\n" else "\t"))}
  }
}