第 4 章 Scala流程控制

最新推荐文章于 2024-07-10 17:19:01 发布

怕被各位卷死

最新推荐文章于 2024-07-10 17:19:01 发布

阅读量100

点赞数

分类专栏： Scala（新版）学习笔记文章标签： scala 开发语言后端 Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_45077811/article/details/128851088

版权

Scala（新版）学习笔记专栏收录该内容

12 篇文章 1 订阅

订阅专栏

4.1 分支控制 if-else

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

4.1.1 单分支

1）基本语法

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

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

2）案例实操

需求：输入人的年龄，如果该同志的年龄小于 18 岁，则输出“童年”

object TestIfElse {
 def main(args: Array[String]): Unit = {
 
 println("input age:")
 var age = StdIn.readShort()
 if (age < 18){
 println("童年")
 }
 }
}

4.1.2 双分支

1）基本语法

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

2）案例实操

需求：输入年龄，如果年龄小于 18 岁，则输出“童年”。否则，输出“成年”。

object TestIfElse {
 def main(args: Array[String]): Unit = {
 println("input age:")
 var age = StdIn.readShort()
 if (age < 18){
 println("童年")
 }else{
 println("成年")
 }
 }
}

4.1.3 多分支

1）基本语法

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

2）案例实操

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

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

（2）需求 2：

Scala 中 if else 表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。

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)
 }
}

（3）需求 3：

Scala 中返回值类型不一致，取它们共同的祖先类型。

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

（4）需求 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)
 }
}

4.2 嵌套分支

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

分支外面的分支结构称为外层分支。嵌套分支不要超过 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)
 }
}

4.3 Switch 分支结构

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

模式匹配涉及到的知识点较为综合，因此我们放在后面讲解。

4.4 For 循环控制

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

4.4.1 范围数据循环（To）

1）基本语法

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

（1）i 表示循环的变量，<- 规定 to

（2）i 将会从 1-3 循环，前后闭合

2）案例实操

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

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

4.4.2 范围数据循环（Until）

1）基本语法

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

（1）这种方式和前面的区别在于 i 是从 1 到 3-1

（2）即使前闭合后开的范围

2）案例实操

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

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

遍历集合

for(i <- array(11,78,87)){
    println(i)
}

for(i <- list(11,78,87)){
    println(i)
}

for(i <- set(11,78,87)){
    println(i)
}

4.4.3 循环守卫

1）基本语法

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

说明：

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

（2）上面的代码等价

for (i <- 1 to 3){
  if (i != 2) {
    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.4.4 循环步长

1）基本语法

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

说明：by 表示步长

2）案例实操

需求：输出 1 到 10 以内的所有奇数

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

输出结果
i=1
i=3
i=5
i=7
i=9

4.4.5 嵌套循环

1）基本语法

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

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

2）基本语法

上面的代码等价

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

小练习：（九九乘法表）

  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9){
      for (j <- 1 to i){
        print(s"${i}*${j}=${i*j}\t")
      }
      println()
    }
    //简写
    for (i <- 1 to 9;j <- 1 to i){
      print(s"${i}*${j}=${i*j}\t")
      if(i == j) println()
  }

4.4.6 引入变量

1）基本语法

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)
}

2）案例实操

上面的代码等价于

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

// 打印输出一个九层妖塔
object Test04_Practice_Pyramid {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9){
      val stars = 2 * i - 1
      val spaces = 9 - i
      println(" " * spaces + "*" * stars)
    }

    for (i <- 1 to 9; stars = 2 * i - 1; spaces = 9 - i){
      println(" " * spaces + "*" * stars)
    }

    for (stars <- 1 to 17 by 2; spaces = (17 - stars) / 2){
      println(" " * spaces + "*" * stars)
    }
  }
}

4.4.7 循环返回值

1）基本语法

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

说明：将遍历过程中处理的结果返回到一个新 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)

4.4.8 倒序打印

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

2）案例实操：

需求：倒序打印 10 到 1

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

4.5 While 和 do..While 循环控制

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

4.5.1 While 循环控制

1）基本语法

循环变量初始化

while (循环条件) {

循环体(语句)

循环变量迭代}

说明：

（1）循环条件是返回一个布尔值的表达式

（2）while 循环是先判断再执行语句

（3）与 for 语句不同，while 语句没有返回值，即整个 while 语句的结果是 Unit 类型()

（4）因为 while 中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在 while 循环的外部，那么就等同于循环的内部对外部的变量造成了影响**，所以不推荐使用**，而是推荐使用 for 循环。

2）案例实操

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

object TestWhile {
 
 def main(args: Array[String]): Unit = {
 var i = 0
   while (i < 10) {
     println("宋宋，喜欢海狗人参丸" + i)
     i += 1
   }
 }
}

4.5.2 do..while 循环控制

1）基本语法

循环变量初始化;

do{

循环体(语句)

循环变量迭代

} while(循环条件)

说明：

（1）循环条件是返回一个布尔值的表达式

（2）do..while 循环是先执行，再判断

2）案例实操

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

object TestWhile {
   def main(args: Array[String]): Unit = {
     var i = 0
     do {
       println("宋宋，喜欢海狗人参丸" + i)
       i += 1
       } while (i < 10)
     }
}

4.6 循环中断

1）基本说明

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

2）案例实操

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

def main(args: Array[String]): Unit = {
   try {
     for (elem <- 1 to 10) {
       println(elem)
       if (elem == 5) throw new RuntimeException
     }
   }catch {
     case e => //什么都不做只是退出循环
   }
   println("正常结束循环")
}

需求 2：采用** Scala 自带的函数，退出循环**

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

需求 3：对 Breaks 进行省略

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("正常结束循环")
   }
}

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

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