Scala的内建控制结构

一：if表达式

　　Scala的if表达式和Java语言的用法一样，if,if else,if elseif else这三种结构。

object If_expression {
  def main(args: Array[String]): Unit = {
    /**
      * Scala的if表达式和Java的一样用法
      */

    val a = readInt()
    if(a > 0){
      println(a+" > 0")
    }else if(a < 0){
      println(a+" < 0")
    }else{
      println(a+" = 0")
    }
  }
}

 二：while 循环

　　Scala的while，do while的用法和Java的用法一样，举例说明下。

object While_loop {
  def main(args: Array[String]): Unit = {
    /**
      * while循环,do while循环和Java的用法一样
      */

    var i = 10
    var sum = 0
    while(i > 0){
      sum += i
      i -= 1
    }
    println(sum)

    i = 10
    sum = 0
    do{
      sum += i
      i -= 1
    }while(i>0)
    println(sum)
  }
}

 三：for表达式

　　Scala的for循环和Java的用法不一样，可以大概分为以下几种。

　　（1）直接遍历数组，有三种

　　（2）遍历数组，表达式中带有过滤条件

object For_expression {
  def main(args: Array[String]): Unit = {
    /**
      * Scala的for循环和Java的用法不一样
      */

    val list = Array(1,2,3,4,5)

    /**
      * 第一种,使用a to b，范围[a,b]，使用下标
      */
    for(i <- 0 to list.length-1){
      print(list.apply(i)+" ")
    }
    println()

    /**
      * 第二种,使用a until b，范围[a,b)，使用下标
      */

    for(i <- 0 until list.length){
      print(list(i)+" ")
    }
    println()

    /**
      * 第三种，直接遍历，不需要下标，i指向list的每个元素
      */
    for(i <- list){
      print(i+" ")
    }
    println()

    /**
      * for循环中使用多个过滤器
      */

    for(i <- list if i%2==0 if i>3){
      print(i+" ")
    }
    println()

    for(i <- list if check(i) ){
      print(i+" ")
    }
    println()

    /**
      * 构造新集合，使用yield语法
      */
    val t = for(i <- list if i>2) yield{
      val k = i * 2 + 10
      k
    }

    println(t.toList)

  }

  def check(a:Int): Boolean = if(a>2) true else false
}

 四：异常处理

　　Scala的异常处理和Java的用法一样，使用try catch语句。

object Try_catch {
  def main(args: Array[String]): Unit = {
    /**
      * Scala的处理异常和Java用法一样
      */

    try {
      val f = new FileReader("try.txt")
    }catch {
      case ex: FileNotFoundException => println("文件不存在")
      case ex: IOException => println("IO异常")
    }finally {
      println("异常处理完成")
    }
  }
}

 五：match匹配

　　Scala的match匹配功能和Java的switch case一样，也有返回值。

object Match_expression {
  def main(args: Array[String]): Unit = {
    /**
      * Scala的match语法类似于Java的switch语法
      */

    /**
      * 正常匹配，然后打印结果
      */
    val name = "alex"
    name match {
      case "Lei" => println("Name is Lei")
      case "alex" => println("Name is alex")
      case "Lily" => println("Name is Lily")
      case _ => println("Other")
    }

    /**
      * 匹配选择，有返回值，而且匹配成功之后不会继续往下匹配
      */
    val fri = "Lily"
    val t = fri match {
      case "Alex" => "A"
      case "Lily" => "L1"
      case "Bob" => "B"
      case "Lily" => "L2"
    }
    println(t)
  }
}

 六：Scala中的break和continue用法

　　Scala中没有break和continue关键字，使用其它的方式实现break和continue的功能，需要导入包，import scala.util.control.Breaks._包。

import scala.util.control.Breaks._
/**
  * @Author:Alex_lei
  * @Description:
  */
object BC {
  def main(args: Array[String]): Unit = {
    /**
      * 这里说的是Java的break和continue，Scala中并没有这个用法
      * 使用变量标记实现
      */


    /**
      * 求前五个元素和,实现break用法
       */

    val arr = Array(1,2,3,4,5,6)
    var sum = 0
    breakable({
      for(i <- arr){
        if(i>5)
          break()
        sum += i
      }
    })
    println(sum)

    /**
      * 求前三个元素的和，实现continue
      */

    sum = 0
    for(i <- arr){
      breakable({
        if(i>3)
          break()
        sum += i
      })
    }
    println(sum)

    /**
      * 二者区别在于执行的循环体在breakable外还是内，二者都是使用break()函数
      */
  }
}