大数据8_05_Scala流程控制

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)
  }
}

单分支: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")
    }
  }
}

双分支: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""")
  }
}

多分支: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 !")
    }
  }
}

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 
    }
      
  }
}

循环步长

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
    }
  }
}
循环守卫
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)
    }
  }
}

倒叙的循环呢?

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)
    }
  }
}

用for循环实现九层妖塔

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

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

object TestYaoTa {
  def main(args: Array[String]): Unit = {
    for (i <- Range(1, 10)) {
      println((" " * (10 - i)) + ("*" * i) + ("*" * (i - 1))) 
    }
  }
}
②while循环

while循环

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

    var i = 1
    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中没有continue关键字,break关键字也没有,但是功能不能少

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

image-20201113211520530

image-20201113211801054

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)
      }
    }
  }
}

如果导包: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)
      }
    }
  }
}
④嵌套循环

嵌套循环

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))
  }
}
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))
    }
  }
}

引入变量

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)
    }
  }
}
循环返回值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)
  }
}

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

需要加``飘号

Thread.`yield`()
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

最佳第六六六人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值