在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。 温馨提示： Scala语言中控制结构和Java语言中的控制结构基本相同，在不考虑特殊应用场景的情况下，代码书写方式以及理解方式都没有太大的区别 1)顺序控制 2)分支控制（单分支, 双分支，多分支） 3)循环控制
程序从上到下逐行地执行，中间没有任何判断和跳转。
Scala中定义变量时采用合法的前向引用。如： def main(args : Array[String]) : Unit = { var num1 = 12 var num2 = num1 + 2 } 错误形式： def main(args : Array[String]) : Unit = { var num2 = num1 + 2 var num1 = 12 }
让程序有选择的的执行,分支控制有三种: 1)单分支 2)双分支 3)多分支
基本语法
if (条件表达式) {
执行代码块 }
说明：当条件表达式为ture 时，就会执行 { } 的代码。
基本语法
if (条件表达式) {
执行代码块1 } else {
执行代码块2 }
说明：当条件表达式成立，即执行代码块1，否则执行代码块2.
判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除；(2)能被400整除
object IfElseDemo { def main(args: Array[String]): Unit = { /* 判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除；(2)能被400整除 分析 1. 有一个变量，保存year 2. 分支控制 3. (1) 和 (2) 条件是 或的关系 4. (1) 中的两个条件是 与的关系 代码 */ var year = 2020 if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { println("year=" + year + "是闰年") } else { println("year=" + year + "不是闰年") } } }1)如果大括号{}内的逻辑代码只有一行，大括号可以省略, 这点和java 的规定一样。 2)Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容.[案例演示] 3)Scala中是没有三元运算符，因为可以这样简写,使用 if – else
在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。嵌套分支不要超过3层
if(){ if(){ }else{ } }
参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下5min】, 输入成绩和性别，进行判断。1分钟思考思路 double second; char gender; 代码
import scala.io.StdIn object Exercise03 { def main(args: Array[String]): Unit = { /* 参加百米运动会，如果用时8秒以内进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下5min】, 输入成绩和性别，进行判断 分析 1. 有两个变量 2. 使用到嵌套分支 */ println("请输入成绩") val second = StdIn.readFloat() if (second <= 8 ) { println("请输入性别") val gender = StdIn.readChar() if (gender == '男') { println("进入男子组决赛") }else { println("进入女子组决赛..") } }else { println("你被淘汰...") } } }出票系统：根据淡旺季的月份和年龄，打印票价 [考虑学生先做5min] scala 没有switch 4_10 旺季： 成人（18-60）：60 儿童（<18）:半价 老人（>60）:1/3
淡季： 成人：40 其他：20 代码
object Exercise04 { def main(args: Array[String]): Unit = { /* 分析 1. 定义月份，年龄，票价 2. 使用嵌套分支业务处理 */ val (month, age, ticket) = (8, 20, 60.0) var buyPrice = 0.0 if (month >= 4 && month <= 10) { if (age >= 18 && age <= 60) { buyPrice = ticket } else if (age < 18) { buyPrice = ticket / 2 } else { buyPrice = ticket / 3 } } else { if (age >= 18 && age <= 60) { buyPrice = 40.0 } else { buyPrice = 20.0 } } println("应付" + buyPrice) } }在scala中没有switch,而是使用模式匹配(match-case )来处理。后面再写
Scala 也为for 循环这一常见的控制结构提供了非常多的特性，这些for 循环的特性被称为for 推导式（for comprehension）或for 表达式（for expression）
如代码所示：
package com.zpark.bigdata.scala.chapter04 object Scala03_For { def main(args: Array[String]): Unit = { // TODO Java中for循环 /* for (int i = 0;i<10;i++){ 循环体 } for (String s : strings ) { 循环体 } */ // TODO Scala中for循环 //使用 1to5 表示循环的范围，1到5。 1.to(5) --> 对象.方法 for(i <- 1 to 5){ println(s"i = ${i}") } //使用 1until5 表示循环的范围，1截止到5（不包含5）。 1.until(5) --> 对象.方法 for(i2 <- 1 until 5){ println(s"i2 = ${i2}") } //Range(start,end,step) step：以2个增长模式增加 for (i3<-Range (1,5,2)){ println(s"i3 = ${i3}") } //嵌套循环 for(i1<-1 to 3){ for(j<- 1 until 3){ println(s"${i1} = ${j}") } } //九成妖塔 for(i <- Range(1,18,2)){ println(" "*((18-i)/2)+ "*"*i+" "*((18-i)/2)) } } } }所谓循环守卫就是增加条件判断，如果条件成立，那么执行循环体，如果不成立，跳过循环体
1)循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue 2)上面的代码等价
这种写思路更清晰一点 for (i<-1 to 3){ if ( i != 2) { println(i+" ") } }
基本案例 for(i <- 1 to 3; j = 4 - i) { print(j + " ") }
对基本案例说明 1)没有关键字，所以范围后一定要加；来隔断逻辑 2)上面的代码等价 for (i <- 1 to 4) { val j = 4 - i println(s"i=ij= {i} j=ij={j}") }也可以写成(scala中推荐使用)
for{i <- 1 to 4
j=4-i} {
println(s"i=ij= {i} j=ij={j}")
}
基本案例 for(i <- 1 to 3; j <- 1 to 3) { println(" i =" + i + " j = " + j) }
对基本案例说明 1)没有关键字，所以范围后一定要加；来隔断逻辑 2)上面的代码等价(处理比较复杂的业务时，使用这个) for (i <- 1 to 3) { for (j <-1 to 3) { println(“ok”) } } 代码
object MutiFor { def main(args: Array[String]): Unit = { for (i <- 1 to 3; j <- 1 to 3) { println(s"i=$i j=$j") } //等价的写法 println("================") for (i <- 1 to 3) { for (j <- 1 to 3) { println(s"i=$i j=$j") } } }基本案例 val res = for(i <- 1 to 10) yield i * 2 println(res)
对基本案例说明 将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字，yield 可以写代码块. 代码
//循环返回值 //默认情况下，for循环的返回值为() //TODO 特殊情况采用yield关键字,表示把每一次循环的结果放到集合当中返回 val res = for(i <- 1 to 10) yield i * 2 println(res)
基本案例 for(i <- 1 to 3; j = i * 2) { println(" i= " + i + " j= " + j) } 可以写成:
对基本案例说明 1){}和()对于for表达式来说都可以 2)for 推导式有一个不成文的约定：当for 推导式仅包含单一表达式时使用圆括号，当其包含多个表达式时使用大括号 3)当使用{} 来换行写表达式时，分号就不用写了 4)代码：
object ForDemo03 { def main(args: Array[String]): Unit = { for {i <- 1 to 3 j = i * 2} { println(" i= " + i + " j= " + j) } }1)scala 的for循环形式和java是较大差异，这点请同学们注意，但是基本的原理还是一样的。 2)scala 的for循环的步长如何控制! [for(i <- Range(1,3,2)] 3)思考题：如何使用循环守卫控制步长 4)代码实现
object ForStep { def main(args: Array[String]): Unit = { //遍历 1-10, 步长为 3 //方式1 使用Range, 他是一个集合 //说明 1： start // 10: end 遍历到(end -1) // 3: 表示step for (i <- Range(1,10,3)) { //until println("i=" + i) } //灵活的使用守卫 [推荐] println("==========使用守卫控制步长==============") for (i <- 1 to 10 if i % 3 == 1 ) { println("i=" + i) } }直接上代码：
//中断循环 //Java中采用的是break语法 //Scala中没有break关键字，但是她可以采用对象的方式来中断循环 //Breaks.breakable{} 它的作用就是将可能抛异常的放在括号里，这样不会中断代码，还会继续运行下边的。类似于try..cath Breaks.breakable{ for(i <- 1 to 10){ if (i == 5){ Breaks.break() } println(s"${i}") } } println("循环终止")第二种方法：
// TODO import scala.util.control.Breaks._ 加上._后,原来的Breaks就可以省略了，直接写成如下代码 breakable{ for(i <- 1 to 10){ if (i == 5){ break() } println(s"${i}") } } println("循环终止")循环变量初始化 //循环的四个要素 while (循环条件) { 循环体(语句) 循环变量迭代 }
画出流程图 输出10句"你好,世界" 代码如下：
object WhileDemo01 { def main(args: Array[String]): Unit = { //输出10 hello var n = 1 while (n <= 10) { println("hello,world" + n) n += 1 //循环遍历的迭代 } }
1)循环条件是返回一个布尔值的表达式2)while循环是先判断再执行语句 3)与If语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()4)因为while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。(scala设计者理念：能使用for循环，就先考虑使用.)
循环变量初始化; do{ 循环体(语句) 循环变量迭代 } while(循环条件)
画出流程图 输入10 “你好,世界”
object DoWhile { def main(args: Array[String]): Unit = { //统计1——200之间能被5整除但不能被3整除的个数 //do..while 循环的四要素 var n = 1 var max = 200 var count = 0 do { if (n % 5 == 0 && n % 3 != 0) { count += 1 } n += 1 }while(n <= max) println("count=" + count) }1.循环条件是返回一个布尔值的表达式
2.do..while循环是先执行，再判断
3.和while 一样，因为do…while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量 ，而变量需要声明在do...while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环
1)统计三个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。 2)统计三个班及格人数，每个班有5名同学。 3)代码
import scala.io.StdIn object Exercise06 { def main(args: Array[String]): Unit = { /* 1统计三个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均 分[学生的成绩从键盘输入]。 2.统计三个班及格人数，每个班有5名同学。 思路分析 1. 定义变量 classNum , stuNum , classTotalScore, totalScore, passStuNum 2. 因为没有数组，所以每次输入完一个班级的成绩后，就立即得到结果 3. 会使用到嵌套循环. */ val classNum = 3 val stuNum = 5 var classTotalScore = 0.0 var totalScore = 0.0 var stuScore = 0.0 var passStuNum = 0 for (i <- 1 to classNum) {//遍历三个班 //将班级成绩清0.0 classTotalScore = 0.0 for (j<-1 to stuNum) {//遍历学生 printf("请输入%d班级的第%d个学生的成绩\n" , i, j) stuScore = StdIn.readDouble() //累计及格的学生个数 if (stuScore >= 60) { passStuNum += 1 } //累计到 classTotalScore classTotalScore += stuScore } //得到班级的总成绩 printf("第%d个班的平均成绩为%.2f\n", i, classTotalScore / stuNum) //累计到totalScore， 为了计算所有班级的总成绩 totalScore += classTotalScore } //统计所有班级的平均分 printf("总有班级的平均分为%.2f\n", totalScore / (classNum * stuNum)) printf("及格的人数有%d\n", passStuNum) }1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】
2.实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
3.设外层循环次数为m次，内层为n次， 则内层循环体实际上需要执行 m * n次。
