scala（三）：流程控制-分支控制、嵌套循环、for、while、do…while循环、循环中断、多支循环

目录

流程控制

分支控制

嵌套分支

for循环控制 

while和do…while循环控制

循环中断

多重循环 

---

流程控制

分支控制

分支控制可以使程序有选择的执行，分支类型有：单分支、双分支、多分支

单分支

基本语法：

if （条件表达式） {
执行代码块
}

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

 

双分支

基本语法：

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

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

 

多分支

基本语法：

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

object Test01 {
  def main(args: Array[String]): Unit = {
    println("input age:")
    var age = StdIn.readShort()
    if (age < 14) {
      println("儿童！！！")
    } else if (age >= 14 && age < 22) {
      println("青年！！！")
    } else if (age >= 22 && age < 60) {
      println("中年！！！")
    } else {
      println("老年！！！")
    }
  }
}

其他if else说明：

object Test01 {
  def main(args: Array[String]): Unit = {
    println("input age:")
    var age = StdIn.readShort()
    //Scala中if else表达式是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容
    val a:Any = if (age < 14) {
      "儿童！！！"
    } else if (age >= 14 && age < 22) {
      "青年！！！"
    } else if (age >= 22 && age < 60) {
      "中年！！！"
    } else {
      "老年！！！"
    }
    println(a)

    println("input age:")
    var age2 = StdIn.readShort()
    //Scala中返回值类型不一致，取它们共同的祖先类型
    val b:Any = if (age2 < 14) {
      "儿童！！！"
    } else if (age2 >= 14 && age2 < 22) {
      "青年！！！"
    } else if (age2 >= 22 && age2 < 60) {
      "abcdefg"
    } else {
      "10000"
    }
    println(b)

    //Java中的三元运算符可以用if else实现
    //如果大括号{}内的逻辑代码只有一行，大括号可以省略。
    // 如果省略大括号，if只对最近的一行逻辑代码起作用
    println("input age:")
    var age3 = StdIn.readShort()
    val c : Any = if (age3 > 18) "成年人" else "儿童"
    "啦啦啦！没有用了！"
    println(c)
  }
}

 

嵌套分支

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

基本结构：

if （） {
   if （） {

  } else {

 }
}

object Test01 {
  def main(args: Array[String]): Unit = {
    println("input age:")
    var age = StdIn.readShort()
    //Scala中if else表达式是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容
    val a:Any = if (age < 14) {
      "儿童！！！"
    } else {
      if (age >= 14 && age < 22) {
        "青年！！！"
      } else {
        if (age >= 22 && age < 60) {
          "中年！！！"
        }
      }
    }
    println(a)
  }
}

for循环控制 

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

object ForTest {
  def main(args: Array[String]): Unit = {
    //范围数据循环（To）
    //前后闭合
    for (i <- 1 to 3) {
      println(i + "哒哒哒")
    }
    println("========")
    //范围数据循环（Until）
    //前闭后开
    for (i <- 1 until 3) {
      println(i + "啵啵啵")
    }
    println("========")
    //循环守卫
    for (i <- 1 to 5 if i != 2) {
      println(i + "啦啦啦")
    }
    println("========")
    //循环步长
    //输入1-10的奇数
    for (i <- 1 to 10 by 2) {
      println("i=" + i)
    }
    println("========")
    //嵌套循环
    for (i <- 1 to 3; j <- 1 to 3) {
      println("i=" + i + "j=" + j)
    }
    println("========")
    //引入变量
    for (i <- 1 to 3; j = 3 - i) {
      println("i=" + i + "j=" + j)
    }
    println("========")
    //循环返回值
    val a = for (i <- 1 to 3) yield {
      i * 2
    }
    println(a)
    println("========")
    //倒序打印
    for (i <- 1 to 3 reverse) {
      println(i)
    }
  }
}

while和do…while循环控制

while

 基本语法：

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

说明：

1）while循环先判断再执行；

2）循环条件返回一个布尔值；

3）while语句没有返回值，整个while语句的结果是Unit类型()；

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

object WhileAndDoWhile {
  def main(args: Array[String]): Unit = {
    var i = 0
    while (i < 5) {
      println("嘿嘿！大笨蛋！！！")
      i += 1  //i = i + 1
    }
  }

}

 do…while

基本语法：

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

说明：

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

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

object WhileAndDoWhile {
  def main(args: Array[String]): Unit = {

    var j = 0
    do {
      println("嘿嘿！又是一个大笨蛋！！！")
      j += 1
    } while (j < 5)
  }
}

循环中断

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

import scala.util.control.Breaks
import scala.util.control.Breaks._

object BreakableTest {
  def main(args: Array[String]): Unit = {
    //采用异常的方式退出循环
    try {
      for (e <- 1 to 5) {
        println(e)
        if (e == 4) throw new RuntimeException
      }
    } catch {
      case ee =>
    }
    println("正常结束循环！")
  }

  //采用scala自带的函数退出循环
  Breaks.breakable(
    for (e <- 1 to 5) {
      println(e)
      if (e == 4) Breaks.break()
    }
  )
  println("正常结束循环！")

  //对break进行省略
  breakable {
    for (e <- 1 to 5) {
      println(e)
      if (e == 4) break
    }
  }
  println("正常结束循环！")

  //跳过continue
  for (e <- 1 to 5) {
    if (e % 2 == 1) {
      println(e)
    } else {println("continue")}
  }
  println("========")

}

多重循环 

 基本说明：

1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do…while均可以作为外层循环和内层循环。建议一般使用两层，最多不要超过 3 层；

2）设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

典型案例：99乘法表

object Test02 {
  def main(args: Array[String]): Unit = {
    for (i <- 1 to 9) {
      for (j <- 1 to i) {
        print(j + "*" + i + "=" + (j * i) + "\t")
      }
      println()
    }
  }

}