scala中break与continue的实现

近日使用scala写Spark程序时候遇到一个问题：在一个循环程序中如何跳出整个循环以及如何跳出本次循环？之前在写Java程序时这两个功能很好实现，即两个关键字：break与continue即可，可是发现Scala中并不支持这两个关键字功能，查了一些资料，发现Scala中定义了一个类可以帮助我们实现这一功能，下面具体介绍scala.util.control.Breaks类实现break与continue功能。

scala中“break”实现

直接上代码解释

//必须引入这个类下面的方法，用于实现break功能
import util.control.Breaks._

/**
  * Created by 东东 on 2017/7/6.
  */
object BreakableTest extends App{

  val list1 = List(1,2,3,4,5)

  //breakable方法与break方法组合使用实现break功能
  //将整个循环放置于breakable方法中，然后需要跳出循环的时候则使用break方法，则跳出整个循环
  breakable{
    println("break功能展示：——————————————")

    for(i <- list1){
      if(i==4) break else println(i)
    }
  }

代码执行结果：

break功能展示：——————————————
1
2
3

可以看到当i==4的时候break实现跳出循环，后续的4与5没有打印出来

scala中“continue”功能实现

代码解释：

import util.control.Breaks._

/**
  * Created by 东东 on 2017/7/6.
  */
object BreakableTest extends App{

    val list2 = List(11,22,33,44,55)
    println("continue功能展示：——————————————")

    //这里与上面的区别是将if-else语句放置在breakable方法内部，而没有将整个循环结构放置在方法内部
    //这样做可以实现结束本次执行而不是整个循环结束，从而实现continue功能
    for(j <- list2){

        breakable{

          if(j==44) break else println(j)

        }
      }
}

代码执行结果：

continue功能展示：——————————————
11
22
33
55

可以看到循环直行到j=44时，跳过，而后续循环依旧进行，打印出了55

scala中Breaks源码解析

/*                     __                                               *\
**     ________ ___   / /  ___     Scala API                            **
**    / __/ __// _ | / /  / _ |    (c) 2003-2013, LAMP/EPFL             **
**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
** /____/\___/_/ |_/____/_/ | |                                         **
**                          |/                                          **
\*                                                                      */

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 {

  //用于后面break方法抛出异常
  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`.
   */
   /**
   * 可以看到这里定义了一个breakable方法,并且接受一个函数作为参数op
   * 这么将函数加上try{}catch{}语句，捕获BreakControl类型的异常
   */
  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.
   *这里定义了一个break方法
   *方法体内直接抛出一个breakException异常
   *这里的breakException异常类型为BreakControl,前面有定义
   * @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

从上面的源码可以看出，breakable与break方法组合用于控制循环的原理就是利用break方法抛出一个异常，然后breakable方法再捕获这个异常，从而结束整个breakable方法块内代码的执行，但是不影响breakable方法体外代码的执行，从而实现控制。