Scala学习之流程控制

分支控制 if-else

基本语法

1. 单分支
2. 双分支
3. 多分支
4. 嵌套分支

package com.gm.chapter03

import scala.io.StdIn

/**
  * @Author: Gm
  * @Date: 2021/6/16 10:13
  */

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

        //单分支
        if (age < 18){
            println("小朋友")
        }

        //双分支
        if (age < 18){
            println("年轻")
        }else {
            println("年迈")
        }

        //多分支
        if (age < 18){
            println("child")
        }else if (age < 30){
            println("strong")
        }else{
            println("old")
        }



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

        val x: Any = if (age <18){
            "未成年"
        }else if(age < 60){
            "成年"
        }else{
            "老年"
        }
        //Java中的三元运算符可以用Scala中的if else实现
        val res1: Any = if (age < 18) "未成年" else "成年"
        "不起作用"//如果大括号{}内的逻辑代码只有一行，大括号可以省略。如果省略大括号，if只对最近的一行逻辑代码起作用。


        //在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层。
        // 分支外面的分支结构称为外层分支，嵌套分支不要超过三层
        val res2 :Any = if (age < 18){
            "童年"
        }else {
            if(age>=18 && age<30){
                "中年"
            }else{
                "老年"
            }
        }

        println(res2)
    }
}

Switch 分支结构

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

For 循环控制

基本语法

1. 循环守卫
2. 循环步长
3. 嵌套循环
4. 引入变量
5. 循环返回值
6. 倒序打印

package com.gm.chapter03

/**
  * @Author: Gm
  * @Date: 2021/6/17 9:59
  */

object TestFor {
  def main(args: Array[String]): Unit = {
    //范围数据循环(To)
    for (i <- 1 to 3) {
      print(i + " ")
    }
    println()
    //范围数据循环(Until)
    for (i <- 1 until 3) {
      print(i + " ")
    }
    println()

    //循环守卫
    for (i <- 1 to 3 if i != 2) {
      print(i + " ")
    }
    println()
    //等价于
    for (i <- 1 to 3) {
      if (i != 2) {
        print(i + " ")
      }
    }

    //循环步长,默认步长为1
    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 (i <- 1 to 3) {
      for (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)
    }
    //等价于
    for {
      i <- 1 to 3
      j = 4 - i
    } {
      println("i=" + i + " j=" + j)
    }
    //等价于
    for (i <- 1 to 3) {
      var j = 4 - i
      println("i=" + i + " j=" + j)
    }

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

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

package com.gm.chapter03

/**
  * @Author: Gm
  * @Date: 2021/6/16 11:29
  */
object ExerciseFor {
  def main(args: Array[String]): Unit = {
    //乘法口诀表
    for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(j + "*" + i + "=" + (i * j))
        print("\t")
      }
      println()
    }
    //简化
    for (i <- 1 to 9; j <- 1 to i) {
      print(j + "*" + i + "=" + (i * j) + "\t")
      if (j == i) println()
    }
    for (i <- 1 to 9) {
      for (j <- 1 to (9 - i)) {
        print(" ")
      }
      for (m <- 1 until 2 * i) {
        print("*")
      }
      println()
    }
    for (i <- 9 to 1 by -1) {
      println(" " * (9 - i) + "*" * (2 * i - 1))
    }
    for {
      i <- 1 to 9
      j = 9 - i
      k = 2 * i - 1
    } {
      println(" " * j + "*" * k)
    }
    for {
      j <- 1 to 8 by 1
      k = 17 - 2 * j
    } {
      println(" " * j + "*" * k)
    }
  }
}

While 和 do…While循环控制

package com.gm.chapter03

/**
  * @Author: Gm
  * @Date: 2021/6/17 16:21
  */

object TestWhile {
  def main(args: Array[String]): Unit = {
    //while和do...while的使用和Java语言中用法相同
    //1.循环条件是返回一个布尔值的表达式
    //2.while循环事先判断再执行语句
    //3.与for语句不同，while语句没有返回值，即整个while语句的结果是Unit类型()
    //4.因为while中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等于循环的内部对外部的变量造成了影响，所以不推荐使用，而是推荐使用for循环。
    var i = 0
    while(i < 10){
      println(i)
      i += 1
    }
    //do...while:循环条件是返回一个布尔值的表达式；do...while循环是限制性，再判断
    i = 0
    do{
      println(i)
      i += 1
    }while(i < 10)
  }
}

循环中断

package com.gm.chapter03

import scala.util.control.Breaks

/**
  * @Author: Gm
  * @Date: 2021/6/17 11:35
  */

object TestBreak {
  def main(args: Array[String]): Unit = {
    //Scala内置控制结构特地去掉了continue，是为了更好的适应函数式编程，
    // 推荐使用函数式的风格解决break和continue的功能，而不是一个关键字。
    // Scala中使用的breakable控制结构来实现break和continue功能。

    //1.采用异常的方式退出循环
    try {
      for (elem <- 1 to 10) {
        println(elem)
        if (elem == 5) throw new RuntimeException
      }
    }catch {
      case e =>
    }
    println("循环正常结束")

    //采用Scala自带的函数，退出循环
    Breaks.breakable(
      for (elem <- 1 to 10) {
        println(elem)
        if (elem == 5) Breaks.break()
      })

    //对Breaks进行省略
    import scala.util.control.Breaks._
    breakable(
      for (elem <- 1 to 10) {
        println(elem)
        if (elem == 5) Breaks.break()
      }
    )

    //continue：循环遍历10以内的所有数据，奇数打印，偶数跳过
    for (elem <- 1 to 10){
      if (elem % 2 == 0){
        println(elem)
      }
    }
  }
}