scala学习二（流程控制)

scala 控制结构

1. 条件表达式

scala的条件表达式的语法结构和java是一样的，示例代码如下：

 /**
   * 条件
   * @param condition
   * @return
   */
  def conditional(condition: Int): Unit ={
    if(condition > 5){
      println("输入数据大于5")
    }else{
      println("输入数据小于5")
    }
  }

scala不支持三目运算,可以使用if else条件语句去代替

    /** scala不支持三目运算 **/
    val i = 1
    (i > 0) ? 1:2
 /** if语句代替三目运算 **/
  if(i>0) 1 else 2

2. 循环达式

scala和java类似有多种循环方式，如是while、for 、for循环和for推导式

a 循环达式 一般表达式

while循环,基本用方法和java一样

 /**
   * while 循环
   */
  def testWhile()={
    var n = 10
    while (n > 0){
      println("while's loop time :" + n)
      n -= 1
    }
  }

for 循环，语句格式for( i <- 表达式），让变量i遍历表达式生成集合的所有元素

/**
   * for 循环
   */
  def testFor()={
    var n = 10
    for(i <- 1 to n){
      println("for's loop time: " + i)
    }
  }

其实在scala中有很多函数可以遍历集合，比如map函数、flatMap函数等等
补充一下，在scala中没有java中break和continue关键字，不过scala的utils.control.Breaks包中有break()方法,break方法是以抛出异常BreakControl来结束，可以看到BreakControl是继承ControlThrowable这个trait的

package scala
package util.control

/** A class that can be instantiated for the break control abstraction.
 *  Example usage:
 *  {{{
 *  val mybreaks = new Breaks
 *  import mybreaks.{break, breakable}
 *
 *  breakable {
 *    for (...) {
 *      if (...) break()
 *    }
 *  }
 *  }}}
 *  Calls to break from one instantiation of `Breaks` will never
 *  target breakable objects of some other instantiation.
 */
class Breaks {

  private val breakException = new BreakControl

  /**
   * A block from which one can exit with a `break`. The `break` may be
   * executed further down in the call stack provided that it is called on the
   * exact same instance of `Breaks`.
   */
  def breakable(op: => Unit) {
    try {
      op
    } catch {
      case ex: BreakControl =>
        if (ex ne breakException) throw ex
    }
  }

  sealed trait TryBlock[T] {
    def catchBreak(onBreak: =>T): T
  }

  /**
   * This variant enables the execution of a code block in case of a `break()`:
   * {{{
   * tryBreakable {
   *   for (...) {
   *     if (...) break()
   *   }
   * } catchBreak {
   *   doCleanup()
   * }
   * }}}
   */
  def tryBreakable[T](op: =>T) = new TryBlock[T] {
    def catchBreak(onBreak: =>T) = try {
      op
    } catch {
      case ex: BreakControl =>
        if (ex ne breakException) throw ex
        onBreak
    }
  }

  /**
   * Break from dynamically closest enclosing breakable block using this exact
   * `Breaks` instance.
   *
   * @note This might be different than the statically closest enclosing block!
   */
  def break(): Nothing = { throw breakException }
}

/** An object that can be used for the break control abstraction.
 *  Example usage:
 *  {{{
 *  import Breaks.{break, breakable}
 *
 *  breakable {
 *    for (...) {
 *      if (...) break
 *    }
 *  }
 *  }}}
 */
object Breaks extends Breaks

private class BreakControl extends ControlThrowable

b 循环达式 高级for循环和for推导式

scala的基本形式是 $变量<-表达式$,其中的表达式可以使用多个表达式或叫生成器用分号组合起来，具体例子可以看下面的代码。

 def advanceLoop()={
    for ( i : Int <- 1 to 10 ; j: Int <- 1 to 10 ) {
      print(10 * i + j + " ")
      if(j == 10){
        println(" ")
      }
    }
  }

还可以添加守卫，用if的Boolean加在循环表达式之后

 /**
   * 多个循环使用；分割，还可以用if添加守卫表达式
   */
  def advanceLoopAddIf()={
    for ( i : Int <- 1 to 10 ; j: Int <- 1 to 10 if i == j) {
      println(10 * i + j + " ")
//      if(j == 10){
//        println(" ")
//      }
    }
  }

还有一个推导式是使用yield，它会返回一个和第一个生成器类型一样的返回值

 def testYield(): Unit ={
      val str = for (c <- "hello"; i <- 0 to 1) yield{
         (c + i ).toChar
      }

      println(str.getClass)

      val set = for ( i <- 0 to 1; c <- "hello" ) yield {
        (c + i ).toChar
      }

      println(set.toString())

    }

输出结果

class java.lang.String
Vector(h, e, l, l, o, i, f, m, m, p)

本文代码链接