scala中选择、循环结构

一、if......else

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

eg:

object Test {
   def main(args: Array[String]) {
      var x = 30;

      if( x < 20 ){
         println("x 小于 20");
      }else{
         println("x 大于 20");
      }
   }
}

2、if......else if  ....else

if(布尔表达式 1){
   // 如果布尔表达式 1 为 true 则执行该语句块
}else if(布尔表达式 2){
   // 如果布尔表达式 2 为 true 则执行该语句块
}else if(布尔表达式 3){
   // 如果布尔表达式 3 为 true 则执行该语句块
}else {
   // 如果以上条件都为 false 执行该语句块
}

eg:

object Test {
   def main(args: Array[String]) {
      var x = 30;

      if( x == 10 ){
         println("X 的值为 10");
      }else if( x == 20 ){
         println("X 的值为 20");
      }else if( x == 30 ){
         println("X 的值为 30");
      }else{
         println("无法判断 X 的值");
      }
   }

3、if ......else嵌套

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

eg:

object Test {
   def main(args: Array[String]) {
        var x = 30;
        var y = 10;

         if( x == 30 ){
            if( y == 10 ){
            println("X = 30 , Y = 10");
         }
      }
   }
}

二、循环

Scala 循环

一般情况下，语句是按顺序执行的：函数中的第一个语句先执行，接着是第二个语句，依此类推。

编程语言提供了更为复杂执行路径的多种控制结构。

循环语句允许我们多次执行一个语句或语句组，

循环类型

Scala 语言提供了以下几种循环类型。

循环类型	描述
while 循环	运行一系列语句，如果条件为true，会重复运行，直到条件变为false。
do...while 循环	类似 while 语句区别在于判断循环条件之前，先执行一次循环的代码块。
for 循环	用来重复执行一系列语句直到达成特定条件达成，一般通过在每次循环完成后增加计数器的值来实现。

1、Scala while 循环

只要给定的条件为 true，Scala 语言中的 while 循环语句会重复执行循环体内的代码块。

Scala 语言中 while 循环的语法：

while(condition)
{
   statement(s);
}

statement(s) 可以是一个单独的语句，也可以是几个语句组成的代码块。

condition 可以是任意的表达式，当为任意非零值时都为 true。当条件为 true 时执行循环。 当条件为 false 时，退出循环，程序流将继续执行紧接着循环的下一条语句。

---

流程图

while 循环的关键点是循环可能一次都不会执行。当条件为 false 时，会跳过循环主体，直接执行紧接着 while 循环的下一条语句。

eg：

object Test {
   def main(args: Array[String]) {
      // 局部变量
      var a = 10;

      // while 循环执行
      while( a < 20 ){
         println( "Value of a: " + a );
         a = a + 1;
      }
   }
}

2、Scala do...while 循环

Scala 语言中，do...while 循环是在循环的尾部检查它的条件。

 do...while 循环会确保至少执行一次循环。

Scala 语言中 do....while 循环的语法：

 

do {
   statement(s);
} while( condition );

---

流程图

如果条件为 true，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。

这个过程会不断重复，直到给定条件变为 false 为止。

eg：

object Test {
   def main(args: Array[String]) {
      // 局部变量
      var a = 10;

      // do 循环
      do{
         println( "Value of a: " + a );
         a = a + 1;
      }while( a < 20 )
   }
}

3、Scala for循环

for 循环允许编写一个执行指定次数的循环控制结构。

Scala 语言中 for 循环的语法：

for( var x <- Range ){
   statement(s);
}

Range 可以是一个数字区间表示 i to j (包含 j)，或者 i until j(不包含 j)。左箭头 <- 用于为变量 x 赋值。

eg：

object Test {
   def main(args: Array[String]) {
      var a = 0;
      // for 循环
      for( a <- 1 to 10){
         println( "Value of a: " + a );
      }
   }
}

eg：

object Test {
   def main(args: Array[String]) {
      var a = 0;
      // for 循环
      for( a <- 1 until 10){
         println( "Value of a: " + a );
      }
   }
}

在 for 循环 中可以使用分号 (;) 来设置多个区间，它将迭代给定区间所有的可能值。

eg：
object Test {
   def main(args: Array[String]) {
      var a = 0;
      var b = 0;
      // for 循环
      for( a <- 1 to 3; b <- 1 to 3){
         println( "Value of a: " + a );
         println( "Value of b: " + b );
      }
   }
}

for 循环集合

for 循环集合的语法如下：

for( var x <- List ){
   statement(s);
}

List 变量是一个集合，for 循环会迭代所有集合的元素。

eg：

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6);

      // for 循环
      for( a <- numList ){
         println( "Value of a: " + a );
      }
   }
}

for 循环过滤

Scala 可以使用一个或多个 if 语句来过滤一些元素。

在 for 循环中使用过滤器的语法。

for( var x <- List
      if condition1; if condition2...
   ){
   statement(s);

可以使用分号(;)来为表达式添加一个或多个的过滤条件。

eg：以下是 for 循环中过滤的实例：

object Test {
   def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);

      // for 循环
      for( a <- numList
           if a != 3; if a < 8 ){
         println( "Value of a: " + a );
      }
   }
}

for 使用 yield

可以将 for 循环的返回值作为一个变量存储。语法格式如下：

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

注意大括号中用于保存变量和条件，retVal 是变量， 循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。

eg：

object Test {
    def main(args: Array[String]) {
      var a = 0;
      val numList = List(1,2,3,4,5,6,7,8,9,10);
      // for 循环
    var retVal = for{
      a <- numList if a != 3; if a < 8
                  }yield a // 输出返回值
    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

循环控制语句

循环控制语句改变代码的执行顺序，通过它可以实现代码的跳转。Scala 以下几种循环控制语句：

Scala 不支持 break 或 continue 语句，但从 2.8 版本后提供了一种中断循环的方式

• Scala break 语句

Scala 语言中默认是没有 break 语句，但是在 Scala 2.8 版本后可以使用另外一种方式来实现 break 语句。

• 当在循环中使用 break 语句，在执行到该语句时，就会中断循环并执行循环体之后的代码块。

语法：

// 导入以下包
import scala.util.control._

// 创建 Breaks 对象
val loop = new Breaks

// 在 breakable 中循环
loop.breakable{
    // 循环
    for(...){
       ....
       // 循环中断
       loop.break;
   }
}

流程图

eg：

import scala.util.control._
object Test {
  def main(args: Array[String]) {
    var a = 0;
    val numList = List(1,2,3,4,5,6,7,8,9,10);
    val loop = new Breaks;
    loop.breakable {
      for( a <- numList){
        println( "Value of a: " + a );
        if( a == 4 ){
          loop.break;
        } 
      }
    }
    println( "After the loop" ); }
}

执行以上代码输出结果为：

Value of a: 1
Value of a: 2
Value of a: 3
Value of a: 4
After the loop

• 中断嵌套循环

eg：

import scala.util.control._
object Test {
  def main(args: Array[String]) {
    var a = 0;
    var b = 0;
    val numList1 = List(1,2,3,4,5);
    val numList2 = List(11,12,13);
    val outer = new Breaks;
    val inner = new Breaks;
    outer.breakable {
      for( a <- numList1){
        println( "Value of a: " + a );
        inner.breakable {
          for( b <- numList2){
            println( "Value of b: " + b );
            if( b == 12 ){ 
              inner.break
            }
          } 
        } // 内嵌循环中断
      }
    } // 外部循环中断
  }
}

执行以上代码输出结果为：

Value of a: 1
Value of b: 11
Value of b: 12
Value of a: 2
Value of b: 11
Value of b: 12
Value of a: 3
Value of b: 11
Value of b: 12
Value of a: 4
Value of b: 11
Value of b: 12
Value of a: 5
Value of b: 11
Value of b: 12

无限循环

如果条件永远为 true，则循环将变成无限循环。可以使用 while 语句来实现无限循环：

object Test {
   def main(args: Array[String]) {
      var a = 10;
      // 无限循环
      while( true ){
         println( "a 的值为 : " + a );
      }
   }
}

可以使用 Ctrl + C 键来中断无限循环。