第二课尚硅谷Scala语言学习-流程控制

最新推荐文章于 2024-02-17 19:38:36 发布

道教儒佛电磁波

最新推荐文章于 2024-02-17 19:38:36 发布

阅读量157

点赞数

文章标签： scala 开发语言

本文链接：https://blog.csdn.net/aa18855953229/article/details/125230472

版权

Scala 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

第二课尚硅谷Scala语言学习-流程控制

文章目录

第二课尚硅谷Scala语言学习-流程控制

第一节 if-else

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

// 当条件表达式为 ture 时，就会执行{ }的代码。
if (条件表达式)	{
	执行代码块
}

2. 双分支

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

3. 多分支

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

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

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. 多分支
    if (age <= 6){
      println("童年")
    } else if(age < 18){
      println("青少年")
    } else if(age < 35){
      println("青年")
    } else if(age < 60){
      println("中年")
    } else {
      println("老年")
    }
    println("===================")

    // 4. 分支语句的返回值
    val result: Any = if (age <= 6){
      println("童年")
      "童年"
    } else if(age < 18){
      println("青少年")
      "青少年"
    } else if(age < 35){
      println("青年")
      age
    } else if(age < 60){
      println("中年")
      age
    } else {
      println("老年")
      age
    }
    println("result: " + result)

    // java中三元运算符 String res = (age >= 18)?"成年":"未成年"

    val res: String = if (age >= 18){
      "成年"
    } else {
      "未成年"
    }

    val res2 = if (age >= 18) "成年" else "未成年"

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

    // 5. 嵌套分支
    if (age >= 18){
      println("成年")
      if (age >= 35){
        if (age >= 60){
          println("老年")
        } else {
          println("中年")
        }
      } else {
        println("青年")
      }
    } else {
      println("未成年")
      if (age <= 6){
        println("童年")
      } else {
        println("青少年")
      }
    }
  }
}

第二节 Switch 分支结构

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

第三节 For 循环控制

Scala 也为 for 循环这一常见的控制结构提供了非常多的特性，这些 for 循环的特性被称为 for 推导式或 for 表达式。
范围数据循环（To）前后闭合

// i  表示循环的变量，<- 规定 to
// i  将会从  1-3  循环，前后闭合
// 
for(i <-  1 to 3){
	print(i + " ")
}
println()

3. 范围数据循环（Until）

// 这种方式和前面的区别在于 i 是从 1 到 2不包括3
// 即使前闭合后开的范围
for(i <- 1 until 3)   {
	print(i  +  " ")
}
println()

循环守卫

// 循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为 true 则进入循环体内部，为false则跳过，类似于continue。
for(i <- 1 to 3 if i != 2)   {
	print(i + " ")
}
println()

// 上面的代码等价
for (i <- 1 to 3){
    if (i != 2)   {
    	print(i + " ")
    }
}

5. 循环步长

// 说明：by 表示步长
for (i <- 1 to 10 by 2)   {
	println("i=" + i)
}

嵌套循环

// 说明：没有关键字，所以范围后一定要加；来隔断逻辑
for(i <- 1 to 3;j <- 1 to 3)   {
	println("i =" + i + "j = " + j)
}

引入变量

// for 推导式一行中有多个表达式时，所以要加  ;  来隔断逻辑
// for 推导式有一个不成文的约定：当  for  推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号，如下
for(i <- 1 to 3;j = 4 - i)   {
	println("i=" + i + "j=" + j)
}

循环返回值, 默认返回值是空。

// 说明：将遍历过程中处理的结果返回到一个新 Vector 集合中，使用 yield 关键字。
// 注意：开发中很少使用。
val res = for(i <- 1 to 10) yield i
println(res)

9. 倒序打印

// 如果想倒序打印一组数据，可以用 reverse。 需求：倒序打印 10 到 1
for(i <- 1 to 10 reverse){
	println(i)
}

综合实例。

package chapter04

import scala.collection.immutable

object Test02_ForLoop {
  def main(args: Array[String]): Unit = {
    // java for语法： for(int i = 0; i < 10; i++){ System.out.println(i + ". hello world") }

    // 1. 范围遍历
    for (i <- 1 to 10){
      println(i + ". hello world")
    }
    for (i: Int <- 1.to(10)){
      println(i + ". hello world")
    }

    println("===========================")
//    for (i <- Range(1, 10)){
//      println(i + ". hello world")
//    }
    for (i <- 1 until 10){
      println(i + ". hello world")
    }

    println("==============================")
    // 2. 集合遍历
    for (i <- Array(12, 34, 53)){
      println(i)
    }
    for (i <- List(12, 34, 53)){
      println(i)
    }
    for (i <- Set(12, 34, 53)){
      println(i)
    }

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

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

    for (i <- 1 to 10 if i != 5){
      println(i)
    }

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

    // 4. 循环步长
    for (i <- 1 to 10 by 2){
      println(i)
    }
    println("-------------------")
    for (i <- 13 to 30 by 3){
      println(i)
    }

    println("-------------------")
    for (i <- 30 to 13 by -2){
      println(i)
    }
    for (i <- 10 to 1 by -1){
      println(i)
    }
    println("-------------------")
    for (i <- 1 to 10 reverse){
      println(i)
    }
    println("-------------------")
//    for (i <- 30 to 13 by 0){
//      println(i)
//    }    // error，step不能为0

    for (data <- 1.0 to 10.0 by 0.3){
      println(data)
    }

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

    // 5. 循环嵌套
    for (i <- 1 to 3){
      for (j <- 1 to 3){
        println("i = " + i + ", j = " + j)
      }
    }
    println("-------------------")
    for (i <- 1 to 4; j <- 1 to 5){
      println("i = " + i + ", j = " + j)
    }

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

    // 6. 循环引入变量
    for (i <- 1 to 10){
      val j = 10 - i
      println("i = " + i + ", j = " + j)
    }

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

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

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

    // 7. 循环返回值
    val a = for (i <- 1 to 10) {
      i
    }
    println("a = " + a)

    val b: immutable.IndexedSeq[Int] = for (i <- 1 to 10) yield i * i
    println("b = " + b)
  }
}

第四节 While 和 do…While 循环控制

While 和 do…While 的使用和 Java 语言中用法相同。
While 循环控制

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

}

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

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

案例实操

package chapter04

object Test05_WhileLoop {
  def main(args: Array[String]): Unit = {
    // while
    var a: Int = 10
    while (a >= 1){
      println("this is a while loop: " + a)
      a -= 1
    }

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

第五节循环中断

Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数式编程，推
荐使用函数式的风格解决break和continue的功能而不是一个关键字。Scala中使用breakable
控制结构来实现break和continue功能。
- 采用异常的方式退出循环
- 采用 Scala 自带的函数，退出循环
- 对 break 进行省略

package chapter04

import scala.util.control.Breaks
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
        println(i)
      }
    } catch {
      case e: Exception =>    // 什么都不做，只是退出循环
    }

    // 2. 使用Scala中的Breaks类的break方法，实现异常的抛出和捕捉
    Breaks.breakable(
      for (i <- 0 until 5){
        if (i == 3)
          Breaks.break()
        println(i)
      }
    )

    breakable(
      for (i <- 0 until 5){
        if (i == 3)
          break()
        println(i)
      }
    )

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

第六节多重循环

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

package chapter04

// 输出九九乘法表
object Test03_Practice_MulTable {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9){
      for (j <- 1 to i){
        print(s"$j * $i = ${i * j} \t")
      }
      println()
    }

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