【Scala】Scala知识点总结之流程控制

• Scala程序代码和所有编程语言代码一样，都会有特定的执行流程顺序，默认情况下是顺序执行，上一条逻辑执行完成后才会执行下一条逻辑，执行期间也可以根据某些条件执行不同的分支逻辑代码。

⌘ 分支控制

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

– 单分支

• IF…ELSE 语句是通过一条或多条语句的执行结果（true或者false）来决定执行的代码块

if(布尔表达式) {
   // 如果布尔表达式为 true 则执行该语句块
}

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if ( b ) {
            println("true")
		}
    }
}

– 双分支

if(布尔表达式) {
   // 如果布尔表达式为 true 则执行该语句块
} else {
   // 如果布尔表达式为 false 则执行该语句块
}

• 如果布尔表达式为 true 则执行接着的大括号内的语句块，否则执行else后的大括号内的语句块。

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val b = true
        if ( b ) {
            println("true")
		} else {
   			println("false")
		}
    }
}

– 多分支

if(布尔表达式1) {
   // 如果布尔表达式1为 true，则执行该语句块
} else if ( 布尔表达式2 ) {
   // 如果布尔表达式2为 true，则执行该语句块
}...
} else {
   // 上面条件都不满足的场合，则执行该语句块
}

• 实现一个小功能：输入年龄，如果年龄小于18岁，则输出“童年”。如果年龄大于等于18且小于等于30，则输出“青年”，如果年龄大于30小于等于50，则输出”中年”，否则，输出“老年”。

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val age = 30
        if ( age < 18 ) {
            println("童年")
        } else if ( age <= 30 ) {
            println("青年")
        } else if ( age <= 50 ) {
            println("中年")
        } else {
            println("老年")
        }
    }
}

• Scala中的表达式都是有返回值的，所以上面的小功能还有其他的实现方式

object ScalaBranch {
    def main(args: Array[String]): Unit = {
        val age = 30
        val result = if ( age < 18 ) {
            "童年"
        } else if ( age <= 30 ) {
            "青年"
        } else if ( age <= 50 ) {
            "中年"
        } else {
            "老年"
        }
        println(result)
   }
}

object Scala09_Loop4 {
  def main(args: Array[String]): Unit = {
    // TODO Scala
    var a = 10
    // 表达式都有返回值
    val b = (a = 20)
    //Unit => ()
    println(b)//()
  }
}

• result的类型判断也只与每个分支的最后一行代码有关， print返回值就是unit，一般定义方法如果没有返回值就是unit，相当于void。
• 一般定义方法如果没有返回值就是unit，相当于void。
• 如果出现异常了,要来表示异常，Scala特意就造了个Nothing。
• Scala通过分号或者换行来分割逻辑。

⌘ 循环控制

• 有的时候，我们可能需要多次执行同一块代码。一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。编程语言提供了更为复杂执行路径的多种控制结构。循环语句允许我们多次执行一个语句或语句组
  Scala语言提供了以下几种循环类型

– for循环

— 基本语法

for ( 循环变量 <- 数据集 )
for ()循环中的i为什么不声明为val或var，i相当于for循环作用中的变量i
for ( 循环变量 <- 数据集 ) {
    循环体
}

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

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5) ) { // 不包含5
            println("i = " + i )
        }
        for ( i <- 1 to 5 ) { // 包含5
            println("i = " + i )
        }
        for ( i <- 1 until 5 ) { // 不包含5
            println("i = " + i )
        }
    }
}

— 循环守卫

• 循环时可以增加条件来决定是否继续循环体的执行,这里的判断条件我们称之为循环守卫

object Scala06_Loop1 {
  def main(args: Array[String]): Unit = {
    // 循环守卫： 条件
    for (i <- Range(1, 5) if i != 3) {
      println("i = " + i)
    }

    for (i <- Range(1, 5)) {
      if (i != 3) {
        println("i = " + i)
      }
    }

  }
}
控制台：
i = 1
i = 2
i = 4
i = 1
i = 2
i = 4

— 循环步长

• scala的集合也可以设定循环的增长幅度，也就是所谓的步长step

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5,2) ) {
            println("i = " + i )
        }
        for ( i <- 1 to 5 by 2 ) {
            println("i = " + i )
        }
    }
}

控制台：
i = 1
i = 3
i = 1
i = 3
i = 5

• i <- Range(1,5,2)输出：1，3；
• i <- 1 to 5 by 2 输出1 ， 3， 5；

— 循环嵌套

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        //方式一
        for ( i <- Range(1,5); j <- Range(1,4) ) {
            println("i = " + i + ",j = " + j )
        }
        //方式二
        for ( i <- Range(1,5) ) {
            for ( j <- Range(1,4) ) {
                println("i = " + i + ",j = " + j )
            }
        }
    }
}
控制台都输出：
i = 1,j = 1
i = 1,j = 2
i = 1,j = 3
i = 2,j = 1
i = 2,j = 2
i = 2,j = 3
i = 3,j = 1
i = 3,j = 2
i = 3,j = 3
i = 4,j = 1
i = 4,j = 2
i = 4,j = 3

• 上面两种嵌套方式的区别就是方式二for和for之间可以添加操作

— 引入变量

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5); j = i - 1 ) {
            println("j = " + j )
        }
    }
}

• Scala 怎么没有三元运算符？

• 使用if else 来代替，如果大括号中代码逻辑只有一行，那么可以省略的

object Scala04_Flow3 {
  def main(args: Array[String]): Unit = {
    // 如果大括号中代码逻辑只有一行，那么可以省略的
    val age = 20

    val s1: String = if (age < 20) {
      "zhangsan"
    } else {
      "lisi"
    }
    
    val s2 = if (age < 20) "zhangsan" else "lisi"
    
    // 如果一行代码中只有一段逻辑，那么可以省略分号。如果有多段逻辑，分号不能省略
    println(s1);println(s2)

  }
}

• 如何只使用一次for循环实现九层妖塔

object Scala08_Loop3 {
  def main(args: Array[String]): Unit = {
    // step 2
    // layer 9
    // 1,3,5,7,9,11,13,15,17
    val num = 9
   
    for (i <- 1 to 2 * num by 2) {
      for (j <- 1 to i) {
        print("*")
      }
      println("")
    }
    
    for (i <- 1 to 2 * num by 2; j = (18 - i) / 2) {
      println(" " * j + "*" * i)
    }

  }
}

• 输出如下：

*
***
*****
*******
*********
***********
*************
***************
*****************

        *
       ***
      *****
     *******
    *********
   ***********
  *************
 ***************
*****************

— 循环返回值

• scala所有的表达式都是有返回值的。但是这里的返回值并不一定都是有值的哟。

• for循环的表达式的返回值就是Unit

• 如果希望for循环表达式的返回值有具体的值，需要使用关键字yield,这种操作可以将一个集合转换为另外一个集合,不过开发不这么用

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

– while循环

— 基本语法

当循环条件表达式返回值为true时，执行循环体代码

while( 循环条件表达式 ) {
    循环体
}

一种特殊的while循环就是，先执行循环体，再判断循环条件是否成立

do {
    循环体
} while ( 循环条件表达式 )

— while循环

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        var i = 0
        while ( i < 5 ) {
            println(i)
            i += 1
        }
    }
}

— do…while循环

object ScalaLoop {
    def main(args: Array[String]): Unit = {
        var i = 5
        do {
            println(i)
        } while ( i < 5 )
    }
}

– 循环中断

• scala是完全面向对象的语言，所以无法使用break，continue关键字这样的方式来中断，或继续循环逻辑，而是采用了函数式编程的方式代替了循环语法中的break和continue

package com.atguigu.bigdata.scala.chapter04
import scala.util.control.Breaks._
object Scala14_Loop9 {
    def main(args: Array[String]): Unit = {
        // breakable 是一个方法，{}其实是参数列表
        // TODO 将一段代码作为参数传给一个方法
        breakable{
            for ( i <- 1 to 5 ) {
                if ( i == 3 ) {
                    // 中断循环
                    break
                }
                println("i = " + i)
            }
        }
        println("yyyyyyy")
    }
}

• breakable 是一个方法，{}其实是参数列表

用博客见证成长，用行动证明我在努力。
如果你有缘看到我博客，对你有帮助、喜欢博客内容，请“点赞” “评论”“收藏”一键三连表示支持哦！