Cris 的 Scala 笔记（五）：流程控制

最新推荐文章于 2023-01-24 14:59:57 发布

cris_zz

最新推荐文章于 2023-01-24 14:59:57 发布

阅读量709

点赞数 2

分类专栏： Scala 文章标签： Scala Spark 基础语法夯实基础笔记整理

本文链接：https://blog.csdn.net/cris_zz/article/details/85010323

版权

Scala 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

- 5. 流程控制

5. 流程控制

5.1 分支控制

单分支

if (条件表达式) {

执行代码块

}

说明：当条件表达式为ture 时，就会执行 { } 的代码

双分支

if (条件表达式) {

执行代码块1

} else {

执行代码块2

}

多分支

if (条件表达式1) {

执行代码块1

}

else if (条件表达式2) {

执行代码块2

}

……

else {

执行代码块n

}

分支控制if-else 注意事项

如果大括号{}内的逻辑代码只有一行，大括号可以省略, 这点和java 的规定一样。
Scala中任意表达式都是有返回值的，也就意味着if else表达式其实是有返回结果的，具体返回结果的值取决于满足条件的代码体的最后一行内容
Scala中是没有三元运算符，但是可以这样写 var result = if(a>0)“a” else “b”
在scala中没有switch,而是使用模式匹配来处理

小练习：

求二元一次方程组的解（ax^2+bx+c=0）

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

  println("请输入a：")
  val a = StdIn.readInt()
  println("请输入b：")
  val b = StdIn.readInt()
  println("请输入c：")
  val c = StdIn.readInt()

  val d = math.pow(b, 2) - 4 * a * c

  if (d > 0) {
    val x1 = (-b + math.sqrt(b * b - 4 * a * c)) / (2 * a)
    var x2 = (-b - math.sqrt(b * b - 4 * a * c)) / (2 * a)
    println(x1.formatted("%.2f") + "," + x2.formatted("%.2f"))
  } else if (d == 0) {
    val x = (-b + math.sqrt(b * b - 4 * a * c)) / (2 * a)
    println(x)
  } else {
    println("无解")
  }

}

5.2 for循环控制

Scala 也为for 循环这一常见的控制结构提供了非常多的特性，这些for 循环的特性被称为for 推导式（for comprehension）或for 表达式（for expression）

范围数据循环方式1

for(i <- 1 to 3){

print(i + " ")

}

i 表示循环的变量， <- 规定 to 规定
i 将会从 1-3 循环，前后闭合

范围数据循环方式2

for(i <- 1 until 3) {

print(i + " ")

}

这种方式和前面的区别在于 i 是从1 到 3-1
前闭合后开的范围

循环守卫

for(i <- 1 to 3 if i != 2) {

print(i + " ")

}

循环守卫，即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue

上面的代码等价

for (i <- 1 to 3){
	if (i != 2) {
		print(i + "")
	}

引入变量

for(i <- 1 to 3; j = 4 - i) {

print(j + " ")

}

没有关键字，所以范围后一定要加；来隔断逻辑
上面的代码等价

for (i <- 1 to 4) {
  val j = i + 1
  println(j)
}

还有另外一种写法

for {
  i <- 1.to(2)
  j = i + 2} {
  println(i + "****" + j)
}

嵌套循环

for (i <- 1.to(3); j <- 1 to 2) {
  println(s"i=${i},j=${j}")
}

没有关键字，所以范围后一定要加；来隔断逻辑
上面的代码等价

for (i <- 1.to(3)) {
  for (j <- 1 to 2) {
    println(i + "--" + j)
  }
}

练习：打印九九乘法表

/*打印九九乘法表*/
for (i <- 1.to(9); j <- 1 to i){
  print(i+"*"+j+"="+(i*j)+"\t")
  if (i == j){
    println()
  }
}

循环返回值

val ints = for (i <- 1.to(3)) yield i * 2
println(ints) // Vector(2, 4, 6)

将遍历过程中处理的结果返回到一个新Vector集合中，使用yield关键字

细节注意

scala 的for循环形式和java是较大差异，这点请同学们注意，但是基本的原理还是一样的。
scala 的for循环是表达式，是有返回值的。java的for循环不是表达式，没有返回值.
scala 的for循环的步长如何控制! [for(i <- Range(1,3,2)]

    /*右闭*/
    for (i <- 1.to(5, 2)) {
      println(i)
    }

    /*右开*/
    for (i <- Range.apply(1, 5, 2)) {
      println("===" + i)
    }

5.3 while 循环

while 循环

循环变量初始化

while (循环条件) {

循环体(语句)

循环变量迭代

}

循环条件是返回一个布尔值的表达式
while循环是先判断再执行语句
与If语句不同，While语句本身没有值，即整个While语句的结果是Unit类型的()
因为while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，也就违背了函数式编程的重要思想(纯函数思想)，所以不推荐使用，而是推荐使用for循环

do…while 循环

循环条件是返回一个布尔值的表达式
do…while循环是先执行，再判断
和while 一样，因为do…while中没有返回值,所以当要用该语句来计算并返回结果时,就不可避免的使用变量，而变量需要声明在do…while循环的外部，那么就等同于循环的内部对外部的变量造成了影响，也就违背了函数式编程的重要思想(纯函数思想)，所以不推荐使用，而是推荐使用for循环

/*while 循环*/
var i = 1
while (i < 2) {
  println(i)
  i += 1
}

/*do while 循环*/
do {
  println("*" + i)
  i += 1
} while (i < 4)

5.4 多重循环

介绍

将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层】
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n=mn次。

5.5 循环中断（重点）

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

细节

在break() 函数代码是

def break(): Nothing = { throw breakException }

breakable(op: =>Unit) 函数, 是一个高阶函数，可以接受另外一个函数或者一段并执行,并处理如果捕获到breakException，就 throw ex

def breakable(op: => Unit) {
  try {
    op
  } catch {
    case ex: BreakControl =>
      if (ex ne breakException) throw ex
  }
}

scala中有这个风格，如果我们传入的是参数【代码】，是多行的，则我们的可以使用{} 替代()
在scala如果要使用continue的逻辑，则使用if-else 来处理
在for循环中，一样可以使用breakable( break() )

练习

100以内的数求和，求出当和第一次大于20的当前数

// 如果不使用 Scala 的异常中断机制
var sum = 0
var flag = true
for (i <- 1.to(100);if flag) {
    sum += i
    if (sum >= 20) {
        println(i)
        flag = false
    }
}

// 如果使用 Scala 的异常中断机制
breakable {
    var sum = 0
    for (i <- 1 to 100) {
        sum += i
        if (sum >= 20) {
            println(i)
            break()
        }
    }
}

实现登录验证，有三次机会，如果用户名为”cris” ,密码”123”提示登录成功，否则提示还有几次机会，请使用for 循环完成

// 如果不使用 Scala 的异常中断机制
    var flg = true
for (i <- 1 to 3; if flg) {

    println("请输入名字：")
    val name = StdIn.readLine()
    println("请输入密码：")
    val password = StdIn.readLine()
    if ("cris".equals(name) && "123".equals(password)) {
        println("登录成功！")
        flg = false
    } else {
        if (i != 3) {
            println("登录失败！你还剩下" + (3 - i) + "次机会！")
        } else {
            println("登录失败！你已经没有机会了！")
        }
    }
}
}

// 如果使用 Scala 的异常中断机制
breakable {
    for (i <- 1 to 3) {
        println("请输入名字：")
        val name = StdIn.readLine()
        println("请输入密码：")
        val password = StdIn.readLine()
        if ("cris".equals(name) && "123".equals(password)) {
            println("登录成功！")
            break()
        } else {
            if (i != 3) {
                println("登录失败！你还剩下" + (3 - i) + "次机会！")
            } else {
                println("登录失败！你已经没有机会了！")
            }
        }
    }
}

换句话说，Scala 通过异常中断机制来完成循环的终止，这个机制得以实现的前提就是函数式编程

根据规则统计路口通过总次数：金额大于50000，每次通过减少5%,；否则每次通过金额减去1000

var money = 100000.0
var count = 0
while (money >= 1000) {
    count += 1
    if (money > 50000) {
        money *= 0.95
    } else {
        money -= 1000
    }
}
println("可以经过" + count + "次路口")