大数据之Scala 流程控制完整使用(第四章)

一、 分支控制 if-else

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

1、(单)分支

1）基本语法

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

说明：当条件表达式为 ture 时，就会执行{ }的代码。

2）案例实操

package chapter04

import scala.io.StdIn

object Test01_IfElse {

  def main(args: Array[String]): Unit = {
    println("请输入您的年龄：")
    val age: Int = StdIn.readInt()

    //1、单分支
    if (age >= 18) {
      println("成年")
    }

    println("================")

    //2、双分支
    if (age >= 18) {
      println("成年")
    } else {
      println("未成年")
    }


    println("================")


    //3、多分枝Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。Scala 中返回值类型不一致，取它们共同的祖先类型。
    val result: Any = if (age <= 6) {
      println("童年")
      "童年"
    } else if (age < 18) {
      println("青少年")
      "青少年"
      age
    } else if (age < 35) {
      println("青年")
      "青年"
    } else if (age < 60) {
      println("中年")
      "中年"
    } else {
      println("老年")
      "老年"
    }

    println(result)
  }

}

2、(双)分支

1）基本语法

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

2）案例实操

package chapter04

import scala.io.StdIn

object Test01_IfElse {

  def main(args: Array[String]): Unit = {
    println("请输入您的年龄：")
    val age: Int = StdIn.readInt()

    println("================")

    //2、双分支
    if (age >= 18) {
      println("成年")
    } else {
      println("未成年")
    }

    println("================")
    println(result)
  }

}

3、(多)分支

1）基本语法

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

2）案例实操

（1）需求 1：需求：输入年龄，如果年龄小于 18 岁，则输出“童年”。如果年龄大于
等于 18 且小于等于 30，则输出“中年”，否则，输出“老年”。

package chapter04

import scala.io.StdIn

object Test01_IfElse {

  def main(args: Array[String]): Unit = {
    println("请输入您的年龄：")
    val age: Int = StdIn.readInt()

    println("================")


    //3、多分枝
    val result: Any = if (age <= 6) {
      println("童年")
      "童年"
    } else if (age < 18) {
      println("青少年")
      "青少年"
      age
    } else if (age < 35) {
      println("青年")
      "青年"
    } else if (age < 60) {
      println("中年")
      "中年"
    } else {
      println("老年")
      "老年"
    }

    println(result)
  }

}

4、Java 中的三元运算符可以用 if else 实现

如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if 只对最近
的一行逻辑代码起作用。

object TestIfElse {
 def main(args: Array[String]): Unit = {
 // Java
// int result = flag?1:0
 // Scala
 println("input age")
 var age = StdIn.readInt()
 val res:Any = if (age < 18) "童年" else "成年" "不起作用"
 println(res)
 } }

5、嵌套分支

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

1）基本语法

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

2）案例实操

需求：如果输入的年龄小于 18，返回“童年”。如果输入的年龄大于等于 18，需要再判
断：如果年龄大于等于 18 且小于 30，返回“中年”；如果其他，返回“老年”。

object TestIfElse {
 def main(args: Array[String]): Unit = {
 println("input age")
 var age = StdIn.readInt()
 val res :String = if (age < 18){
 "童年"
 }else {
 if(age>=18 && age<30){
 "中年"
 }else{
 "老年"
 }
 }
 println(res)
 } }

二、For 循环控制

Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for 循环的特性被称 为 for 推导式或 for 表达式。

1、范围数据循环（To）

1）基本语法

    for (i <- 1 to 10) {
      println(i + " :HELLO WORD")
    }

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

2）案例实操

需求：输出 5 句 “宋宋，告别海狗人参丸吧”

object Test02_ForLoop {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 10) {
      println(i + " :HELLO WORD")
    }
    }

2、范围数据循环（Until）

1）基本语法

   //到九的第二种方式
    for (i <- 1 until 10) {
      println(i + " :HELLO WORD")
    }

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

2）案例实操

需求：输出 5 句 “宋宋，告别海狗人参丸吧”

object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 until 5 + 1){
 println("宋宋，告别海狗人参丸吧" + i)
 }
 } }

3、循环守卫

1）基本语法

   //3、循环守卫
    for (i <- 1 to 10 if i != 5) {
      println(i)
    }

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

（2）上面的代码等价

    for (i <- 1 to 10){
      if (i != 5) {
        print(i + " ")
      } }

2）案例实操

需求：输出 1 到 5 中，不等于 3 的值

object TestFor {
 def main(args: Array[String]): Unit = {
 for (i <- 1 to 5 if i != 3) {
 println(i + "宋宋")
 }
 } }

4、循环步长

1）基本语法

    //循环步长
    for (i <- 1 to 10 by 2) {
      println(i)
    }

说明：by 表示步长

2）案例实操

for (i <- 1 to 10 by 2) {
println("i=" + i)
}

输出结果

i=1
i=3
i=5
i=7
i=9

5、嵌套循环

1）基本语法

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

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

2）基本语法

上面的代码等价

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

6、引入变量

1）基本语法

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

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

    for {
      i <- 1 to 10;
      j = 10 - i
    } {

      println("i= " + i + ", " + "j = " + j)
    }

2）案例实操

上面的代码等价于

    for (i <- 1 to 10) {
      var j = 10 - i
      println("i= " + i + ", " + "j = " + j)
    }

7、循环返回值

1）基本语法

    // yield 变成链式集合
    val b = for (i <- 1 to 10) yield i
    println(b)

说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。
注意：开发中很少使用

2）案例实操

需求：将原数据中所有值乘以 2，并把数据返回到一个新的集合中

object TestFor {
 def main(args: Array[String]): Unit = {
 var res = for(i <-1 to 10) yield {
 i * 2
 }
 println(res)
 } }

输出结果：
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

8、倒序打印

1）说明：如果想倒序打印一组数据，可以用 reverse。

2）案例实操：

需求：倒序打印 10 到 1
reverse 倒序函数

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

三、 While 和 do…While 循环控制

While 和 do…While 的使用和 Java 语言中用法相同。

1、While 循环控制

1）基本语法

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

2）案例实操

需求：输出 10 句 "whis is a while loop

   //while
    var a: Int = 10
    while (a >= 1) {
      println("whis is a while loop : " + a)
      a += 1
    }

2、do…while 循环控制

1）基本语法

 循环变量初始化;
 do{
 循环体(语句)
 循环变量迭代
 } while(循环条件)
说明
（1）循环条件是返回一个布尔值的表达式
（2）do..while 循环是先执行，再判断

2）案例实操

需求：输出 10 句 “宋宋，喜欢海狗人参丸”

object TestWhile {
    var b: Int = 0
    do {
      println("whis is a while loop 1: " + b)
      b -= 1
    } while (b > 0)

 } }

四、循环中断

1）基本说明

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

2）案例实操一

需求 1：采用异常的方式退出循环

package chapter04

import scala.util.control.Breaks

object Test06_Break {
  def main(args: Array[String]): Unit = {
    //1、采用抛出异常的方式，推出循环
    try{
      for (i <- 0 until 5) {
        if (i == 3) {
          throw new RuntimeException
        }
      }
    } catch {
      case e: Exception => //什么都不做、只是退出循环
    }

    println("这个是循环代码外部的")
  }
}

3）案例实操二

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

package chapter04

import scala.util.control.Breaks

object Test06_Break {
      //2、使用Scala中的Breake类的brecks 类的break方法，实现异常的抛出和普抓
    //不包含　until　
    Breaks.breakable(
      for (i <- 0 until 5) {
        if (i == 3) {
          Breaks.break()
          println(i)
        }
      }
    )
}

4）案例实操三

对 break 进行省略

import scala.util.control.Breaks._
object TestBreak {
 def main(args: Array[String]): Unit = {
 
 breakable {
 for (elem <- 1 to 10) {
 println(elem)
 if (elem == 5) break
 }
 }
 
 println("正常结束循环")
 } }

5）案例实操四

循环遍历 10 以内的所有数据，奇数打印，偶数跳过（continue）

object TestBreak {
 def main(args: Array[String]): Unit = {
    for (elem <- 1 to 10) {
       if (elem % 2 == 1) {
         println(elem)
         } else {
         println("continue")
     }
   }
      }     
   }

四、多重循环

1）基本说明

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

2）案例实操

需求：打印出九九乘法表

    for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(j + "*" + i + "=" + (i * j) + "\t")
      }
      println()
    }

使用$取值法

   for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(s"$j * $i = ${i * j} \t")
      }
      println()
    }