分支控制if-else

让程序有选择的的执行,分支控制有三种: 单分支、双分支、多分支

单分支

基本语法：当条件表达式为ture 时，就会执行 { } 的代码。

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

案例：

println("输入年龄")
val age = StdIn.readInt()
if (age > 18) {
	println("age > 18")
}
1
2
3
4
5

双分支

基本语法：当条件表达式成立，即执行代码块1，否则执行代码块2

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

案例：

    val age = 6
    if (age > 18) {
      println("age > 18")
    } else {
      println("age <= 18")
    }

1
2
3
4
5
6
7
8

多分支

基本语法：当条件表达式1成立时， 即执行代码块1，如果表达式1 不成立，才去判断表达式2是否 成立，如果表达式2成立，就执行代码块2，以此类推，如果所有的表达式都不成立，则执行 else 的代码块，注意， 只能有一个执行入口。

if (条件表达式1) {
        执行代码块1
}
else if (条件表达式2) {
        执行代码块2
}
……
else {
        执行代码块n
}      
1
2
3
4
5
6
7
8
9
10

案例：

    val score = StdIn.readDouble()
    if (score == 100) {
      println("成绩为100分时，奖励一辆BMW")
    } else if (score > 80 && score <= 99) { //写法1使用范围，写法2就是严格的判断
      println("成绩为(80，99]时，奖励一台iphone7plus")
    } else if (score >= 60 && score <= 80) {
      println("奖励一个 iPad")
    } else {
      println("没有任何奖励")
1
2
3
4
5
6
7
8
9

类三元运算符的简写

val result = if (flg) 1 else 0// 因为 scala 的if-else 是有返回值的，因此，本身这个语言也不需要三元运算符
1

嵌套分支
在一个分支结构中又完整的嵌套了另外一个完整的分支结构，里面的分支的结构称为内层分支，外面的分支结构称为外层分支。
嵌套分支最好不要超过三层

if(){
	if()
	else{
	}
}
1
2
3
4
5

循环结构

循环语句允许我们多次执行一个语句或语句组，下面是大多数编程语言中循环语句的流程图：

for循环

for 循环允许您编写一个执行指定次数的循环控制结构，用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。
循环方式

//语法1：
//Range 可以是一个数字区间表示 i to j ，或者 i until j
//左箭头 <- 用于为变量 x 赋值。
//def range(start: Int, end: Int): Array[Int] = range(start, end, 1)
for( var x <- Range ){
   statement(s);
}
1
2
3
4
5
6
7

案例：两种语句效果不同，to包含边界，until不包含边界

//def to(end: Int): Range.Inclusive = Range.inclusive(self, end)
for(i <- 1 to 3){
    print(i + " ")
}
println()
//1 2 3

//def until(end: Int, step: Int): Range = Range(self, end, step)
for(i <- 1 until 3) {  //等价于for(i <- range(-1,3))
    print(i + " ")
}
println()
//1 2
1
2
3
4
5
6
7
8
9
10
11
12
13

过滤器
Scala的for循环允许使用一个或多个if语句过滤掉一些元素。以下是for循环与过滤器的语法。 要为for表达式添加多个过滤器，使用分号(;)分隔过滤器。（类似continue）

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

yield
可以将变量中的for循环存储返回值，或通过函数返回。为此，您可以通过关键字yield来为for表达式的正文添加前缀。

var retVal = for{ var x <- List
   if condition1; if condition2...
}
yield x
1
2
3
4

案例：

var a = 0;
val numList = List(1,2,3,4,5,6,7,8,9,10);
 
// for loop execution with a yield
var retVal = for{ a <- numList if a != 3; if a < 8 }yield a
 
// Now print returned values using another loop.
for( a <- retVal){
	println( "Value of a: " + a );
}

//    Value of a: 1
//    Value of a: 2
//    Value of a: 4
//    Value of a: 5
//    Value of a: 6
//    Value of a: 7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

自定义步长
scala可以通过三种方法设置循环步长

//法1：利用Range函数。   
for (i <- Range(1, 10, 2)) {
	println("i=" + i)
}
//法2：利用for循环守卫。
for (i <- 1 to 10 if i % 2 == 1) {
	println("i=" + i)
}

//法3：利用by方法
for (i <-(1,10).by(2)) {
	println("i=" + i)
}
//当以下情况判断为空
/**override final val isEmpty = (
  *       (start > end && step > 0)
  *    || (start < end && step < 0)
  *    || (start == end && !isInclusive)
  *  )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

嵌套循环
嵌套循环用于初始化或迭代多维数组或打印图案。 Scala可以使用常规嵌套循环的同时，提供了一种在编程语言中使用嵌套循环的有效方法。

//常规方式
loop1{
	loop2{
		//code to be executed… 
	}
}


1
2
3
4
5
6
7
8

方法一：
for(i <- 1 to 2){
	for(j <- 1 to 2)
		println("(" + i + "," + j + ")")
}
//结果
//(1,1)
//(1,2)
//(2,1)
//(2,2)

方法二
for(i <- 1 to 2 ; j <- 1 to 2){
	println("(" + i + "," + j + ")")
}
//(1,1)
//(1,2)
//(2,1)
//(2,2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

while循环

当满足条件时进入循环，进入循环后，当条件不满足时，跳出循环。
(1）循环条件是返回一个布尔值的表达式
(2) while循环是先判断再执行语句
(3)与for语句不同,while语句没有返回值，即整个while语句的结果是Unit类型()
(4)因为 while 中没有返回值，所以当要用该语句来计算并返回结果时，就不可避免的使用变量，而变量需要声明在while循环的外部，那么就等同于循环的内部对外部的变量造成了影响。更推荐使用for循环。

循环方式

//语句(statement(s))可能是一个单一语句或一个语句块
//条件(condition)可以是任何表达式，true是任何非零值。循环在条件为真时循环
//当条件(condition)变为false时，程序控制传递到循环之后的行代码。

while(condition){
   statement(s);
}
1
2
3
4
5
6
7

案例：

var a:Int=10
while (a >= 1){
  println("this is a while loop: " +a)
  a -= 1
}
1
2
3
4
5

循环中断

1.采用抛出异常的方式，退出循环

   try {
      for (i <- 0 until 5) {
        if (i == 3)
          throw new RuntimeException
        println(i)
      }
    } catch {
      case e: Exception => //什么都不做，只是退出循环
    }
  }
1
2
3
4
5
6
7
8
9
10

Scala内置控制结构特地去掉了break和continue，是为了更好的适应函数式编程，推荐使用函数式的风格解决break和continue的功能,而不是一个关键字。Scala中使用breakable控制结构来实现break 和continue功能。
2.使用Scala中的Breaks类的break方法，实现绿常的跑出和捕捉
Breaks.breakable方法实际上就是包装了try-catch

Breaks.breakable(

      for (i <- 0 until 5) {
        if (i == 3)
          throw new RuntimeException
        println(i)
      }
    )
1
2
3
4
5
6
7
8