Skip to content

Latest commit

 

History

History
477 lines (427 loc) · 11.5 KB

scala流程控制.md

File metadata and controls

477 lines (427 loc) · 11.5 KB

一、 分支控制 if-else

和 Java 中的 if-else 一致

  1. 单分支, 语法

    if  (条件表达式)  {
    	执行代码块
    }

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

    需求:输入人的年龄,如果该同志的年龄大于18岁,则输出“age > 18”

    object TestIfElse {
        def main(args: Array[String]): Unit = {
            
            println("input age:")
            var age = StdIn.readShort()
    
            if (age > 18){
                println("age>18")
            }
        }
    }
    
  2. 双分支 语法

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

    需求:输入年龄,如果年龄大于18岁,则输出“age >18”。否则,输出“age <= 18”。

    object TestIfElse {
        def main(args: Array[String]): Unit = {
    
            println("input age:")
            var age = StdIn.readShort()
    
            if (age > 18){
                println("age>18")
            }else{
                println("age<=18")
            }
        }
    }
  3. 多分支 语法

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

    需求:岳小鹏参加Scala考试,他和父亲岳不群达成承诺:如果,成绩为100分时,奖励一辆BM;成绩为(80,99]时,奖励一台iphone;其它时,什么奖励也没有。

    object TestIfElse {
        def main(args: Array[String]): Unit = {
    
            println("请输入成绩")
            val grade = StdIn.readInt()
    
            if (grade == 100){
                println("成绩为100分,奖励一辆BM")
            }else if (grade > 80 && grade <= 90){
                println("奖励一台iphone")
            }else{
                println("什么奖励也没有")
            }
        }
    }

    需求:Scala中if else表达式其实是有返回值的,具体返回值取决于满足条件的代码体的最后一行内容。

    object TestIfElse {
        def main(args: Array[String]): Unit = {
    
            println("input your age")
            var age = StdIn.readInt()
    
            var res = if(age > 18){
                "您以成人"
            }else{
                "小孩子一个"
            }
    
            println(res)
        }
    }

和 Java 一样,如果大括号{}内的逻辑代码只有一行,大括号可以省略。


二、嵌套分支

语法

if(){
	if(){
	
	}else{
	
	}	
}

需求:参加百米运动会,根据性别提示进入男子组或女子组。如果是女子组,用时8秒以内进入决赛,否则提示淘汰。

object TestIfElse {

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

        println("输入性别:")
        var gender = StdIn.readChar()

        if (gender == '男'){
            println("男子组")
        }else{
            println("女子组")
            
            println("输入成绩:")
            var grade = StdIn.readDouble()

            if (grade > 8.0){
                println("你被淘汰了")
            }else{
                println("成功晋级")
            }
        }
    }
}

三、Switch 分支结构

在Scala中没有Switch,而是使用模式匹配来处理。


四、For循环控制

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

4.1 范围数据循环方式 n to m

语法:

for(i <- 1 to 3){
  print(i + " ")
}
println()
  • i 表示循环的变量,<- 规定to
  • i 将会从 1-3 循环,前后闭合

需求:输出10句 "hi, kino"

object TestFor {
    def main(args: Array[String]): Unit = {
        for(i <- 1 to 10){
            println("hi, kino"+i)
        }
    }
}

4.2 范围数据循环方式 n until m

语法:

for(i <- 1 until 3) {
  print(i + " ")
}
println()
  • 这种方式和前面的区别在于i是从1到3-1
  • 即使前闭合后开的范围

4.3 循环守卫

语法:

for(i <- 1 to 3 if i != 2) {
  print(i + " ")
}
println()
  • 循环守卫,即循环保护式(也称条件判断式,守卫)。保护式为true则进入循环体内部,为false则跳过,类似于continue。

  • 上面的代码等价于

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

需求:输出1到10中,不等于5的值

object TestFor {
    def main(args: Array[String]): Unit = {
        for (i <- 1 to 10 if i != 5) {
            println(i + "")
        }
    }
}

4.4 循环步长

语法:

for (i <- 1 to 10 by 2) {
      println("i=" + i)
}
  • by表示步长

需求:输出1到10以内的所有奇数

for (i <- 1 to 10 by 2) {
	println("i=" + i)
}

结果输出:

i=1
i=3
i=5
i=7
i=9

4.5 嵌套循环

语法:

for(i <- 1 to 3; j <- 1 to 3) {
    println(" i =" + i + " j = " + j)
}
  • 没有关键字,所以范围后一定要加;来隔断逻辑

上面的代码等价(当 第一层循环和 第二层循环 中间没有任何操作时才可以使用上面的代码)

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

4.6 引入变量

语法:

for(i <- 1 to 3; j = 4 - i) {
    println("i=" + i + " j=" + j)
}
  • for推导式一行中有多个表达式时,所以要加;来隔断逻辑
  • for推导式有一个不成文的约定:当for推导式仅包含单一表达式时使用圆括号,
  • 当包含多个表达式时,一般每行一个表达式,并用花括号代替圆括号,如下
     for {
         i <- 1 to 3
     j = 4 - i
     } {
         println("i=" + i + " j=" + j)
     }

上面的代码等价于(指的是 语法 展示的代码)

for (i <- 1 to 3) {
    var j = 4 - i
    println("i=" + i + " j=" + j)
}

4.7 循环返回值

语法:

val res = for(i <- 1 to 10) yield i
println(res)
  • 将遍历过程中处理的结果返回到一个新Vector集合中,使用yield关键字

需求:将原数据中所有值乘以2,并把数据返回到一个新的集合中。

object TestFor {

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

        var res = for( i <-1 to 10 ) yield {
            i * 2
        }

        println(res)
    }
}

输出结果:
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

五、While循环控制

语法:

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

需求:输出10句 "hi,kino"

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

        while (i < 10) {
            println("hi,kino" + i)
            i += 1
        }
    }
}

六、do..while循环控制

语法:

do{
       循环体(语句)
       循环变量迭代
} while(循环条件)
  • 循环条件是返回一个布尔值的表达式
  • do..while循环是先执行,再判断

需求:输出10句 "hi,kino"

object TestWhile {
    def main(args: Array[String]): Unit = {
        var i = 0
        do {
            println("hi,kino" + i)
            i += 1
        } while (i < 10)
    }
}

七、多重循环控制

需求:打印出九九乘法表

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

可以简写成

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

八、While循环中断

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

需求:循环遍历10以内的所有数据,数值为5,结束循环(break)

我们一步步推导出 scala 中使用的 breakable ①

def main(args: Array[String]): Unit = {
    try{
        for (i <- 1 to 10) {
            println(i)
            if(i == 5) throw new IllegalArgumentException
        }
    } catch {
        case e =>
    }
    println("正常输出....")
}

输出结果

1
2
3
4
5
正常输出....

② 此时已经实现了我们的需求, 但是这样写 手动抛出异常 写 try catch 和麻烦 scala 中 体重了 Breaks 包 来抛出异常以及捕获异常

import scala.util.control.Breaks

def main(args: Array[String]): Unit = {
   Breaks.breakable(
        for (i <- 1 to 10) {
            println(i)
            if (i == 5) Breaks.break()
        }
    )
    println("正常输出....")
}

③ 我们在 Java 中, 导入某个包下所有类,可以使用 import scala.util.* 指定导入 util 下所有的类,在这里我们也可以批量导入

// scala 中
import scala.util.control.Breaks._

object HelloWorld {
    def main(args: Array[String]): Unit = {
        breakable(
            for (i <- 1 to 10) {
                println(i)
                // 这里 break() 的括号中无参数, 也可以省略
                // if (i == 5) break()
                if (i == 5) break
            }
        )
        println("正常输出....")
    }
}