大数据8_05_Scala流程控制_scala函数式编程import scala.util.control.breaks._ objec

6 流程控制

6.1 分支控制

scala中的表达式都是有返回值的。

返回值为满足条件的最后一行的代码的执行结果。

Scala是基于Java语言开发的，所以是强类型语言。

表达式的返回值

object TestIf_Else {
  def main(args: Array[String]): Unit = {
    val season = "spring"
    //将if-elseif-else的结果赋值给变量result
    val result = if (season == "spring")
      "spring"
    else if (season == "summer")
      "summer"
    else if (season == "autumn")
      "autumn"
    else
      "winter"
    println(result)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

单分支：if

object TestIf {
  def main(args: Array[String]): Unit = {
    val name = "Tom and Jerry"
    val age = 28
    //if的逻辑语句只有一行可以省略大括号，java也是
    if (age > 18)
      println(name)

    if (age < 18){
      println("too young")
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

双分支：if - else

object TestIfElse {
  def main(args :Array[String]) : Unit = {
    val name = "Tom"
    val age = 28
    if(age > 18)
      println(s"name: $name, age: bigger than 18")
    else 
      println(s"""name: $name, age: $age""")
  }
}
1
2
3
4
5
6
7
8
9
10

多分支：if - else if - else

object TestIf_Else {
  def main(args : Array[String]) : Unit = {
    val season = "spring"

    //注意scala中的==是做了非空校验的equals()
    if (season=="spring"){
      println(s"now is spring !")
    }else if (season.equals("summer")){
      println(s"now is summer !")
    }else if (season=="autumn"){
      println(s"now is autumn !")
    }else{
      println(s"now is winter !")
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

6.2 循环控制

①for循环

for循环的语句：for(循环变量 <- 数据集){ 循环体 }

这里的数据集可以是任意类型的数据集合，比如字符串，集合，数组等。

object TestFor {
  def main(args : Array[String]):Unit ={
    1//① Range()
    for (i <- Range(1, 5)){
      println(i)  //1 2 3 4 不包括5，和python的range一样
    }
    println("=============================")
    //② to
    for (i <- 1 to 5){
      println(i)  //1 2 3 4 5
    }
    println("=============================")
    //③ until
    for (i <- 1 until 5){
      println(i)  //1 2 3 4 不包含5
    }
    println("==============================")
    //遍历字符串
    for (i <- "string"){
      println(i)
    }
    println("===============================")
    //遍历集合
    var list = 1 to 5
    for(i <- list){
      println(i)  //1 2 3 4 5 
    }
      
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

循环步长

object TestFor2 {
  def main(args: Array[String]): Unit = {
    /*
    * Java 中的
    * for(int i= 0; i <= 10; i+=2){}
    * 这样是每两个数，执行一次循环
    * */
    //①方式1 to by
    for (i <- 0 to 10 by 2){
      println(i)  //0 2 4 6 8 10
    }
    //② 方式2 until by
    for (i <- 0 until 10 by 2){
      println(i)  //0 2 4 6 8
    }
    //③ 方式3 range
    for (i <- Range(0, 10, 2)){
      println(i)  //0 2 4 6 8
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

循环守卫

object TestFor3 {
  def main(args: Array[String]): Unit = {
    //输出1-10以内的所有的偶数
    for (i <- Range(1, 11)) {
      if (i % 2 == 0) {
        println(i)
      }
    }
    //在scala中使用循环守卫，更方便
    //另外if后面如果是一条执行语句可以省略小括号
    for (i <- Range(1, 11) if i % 2 == 0) {
      println(i)
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

倒叙的循环呢？

object TestFor4 {
  def main(args: Array[String]): Unit = {
    //方式1：range(5, 0, -1)
    for (i <- Range(5, 0, -1)) {
      println(i)
    }
    //方式2：do by
    for (i <- 5 to 1 by -1) {
      println(i)
    }
    //方式3：until by
    for (i <- 5 until (0) by (-1)) {
      println(i)
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

用for循环实现九层妖塔

注意！字符串可以*一个数字，表示这个字符串重复多少次

必须是字符串在前，数字在后

object TestYaoTa {
  def main(args: Array[String]): Unit = {
    for (i <- Range(1, 10)) {
      println((" " * (10 - i)) + ("*" * i) + ("*" * (i - 1))) 
    }
  }
}
1
2
3
4
5
6
7

②while循环

while循环

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

    var i = 1
    while ( i > 5){
      println(i)
      i += 1
    }
  }
}
1
2
3
4
5
6
7
8
9
10

do-while循环

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        var i = 5
        do {
            println(i)
        } while ( i < 5 )
    }
}
1
2
3
4
5
6
7
8

③循环中断

scala中没有continue关键字，break关键字也没有，但是功能不能少

scala采用面向对象的方式实现break操作

import scala.util.control.Breaks

object TestBreak {
  def main(args: Array[String]): Unit = {
    //Breaks.break()会抛出异常，会改变了逻辑
    //把可能会终端的程序放在Breaks.breakable{}内。真的类似于try
    //Breaks.break()：采用抛出异常的方式改变循环操作。
    //Breaks.breakable()：采用捕捉异常的方式来处理break方法带来的异常。
    Breaks.breakable{
      for(i <- Range(0, 10)){
        if (i == 5){
          Breaks.break()
        }
        println(i)
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

如果导包：import scala.util.control.Breaks._表示需要Breaks内的哪个包就导入哪个包，那么就可以省略包名。

import scala.util.control.Breaks._

object TestBreak {
  def main(args: Array[String]): Unit = {
    //Breaks.break()会抛出异常，会改变了逻辑
    //把可能会终端的程序放在Breaks.breakable{}内。真的类似于try
    breakable{
      for(i <- Range(0, 10)){
        if (i == 5){
          break()
        }
        println(i)
      }
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

④嵌套循环

嵌套循环

object TestFor6 {
  def main(args: Array[String]): Unit = {
    
    var list = Array(11, 24, 44, 22, 55, 20, 39, 21)
    //冒泡排序
    for (i <- Range(0, list.length); j <- Range(0, list.length-i-1)){
      if(list(j) > list(j + 1)){
        var temp = list(j + 1)
        list(j + 1) = list(j)
        list(j) = temp
      }
    }

    println(java.util.Arrays.toString(list))
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

object BubbleSort {
  def main(args: Array[String]): Unit = {
    var list = Array(12, 33, 28, 10, 38, 21, 34)
    //冒泡排序
    for (i <- Range(0, list.length)) {
      for (j <- Range(0, list.length - i - 1)){
        if (list(j) > list(j + 1)){
          var temp = list(j + 1)
          list(j + 1) = list(j)
          list(j) = temp
        }
      }
    }
    //输出结果
    for (i <- list.indices){
      println(list(i))
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

引入变量

object TestFor7 {
  def main(args: Array[String]): Unit = {
    for (i <- Range(1, 6)) {
      var j = i + 1
      println(j)
    }
    //循环中引入变量
    for (i <- 1 until 6; j = i + 1) {
      println(j)
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12

⑤循环返回值yield

yield关键字可以将循环体的每一个执行结果返回，使用Vector集合接收

如果使用yield关键字，那么循环的返回值将是()也就是Unit

object TestFor8 {
  def main(args: Array[String]): Unit = {
    val result = for (i <- Range(1, 6)) {
      i * 2
    }
    println(result) //()

    //yield关键字可以将循环体的每一个执行结果返回，使用Vector集合接收
    val result2 = for (i <- Range(1, 6)) yield {
      i * 2
    }
    println(result2)  //Vector(2, 4, 6, 8, 10)
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

yield是作为scala的一个关键字，那么调用Thread的yield方法怎么调用呢？

需要加``飘号

Thread.`yield`()
1