scala中breakable的用法

breakable在Scala中是一个非常有用的方法，它可以在循环中使执行流程立即退出循环。它的语法形式如下：

import scala.util.control.Breaks._

breakable {
  // 循环代码
  // 当条件满足时，调用break方法
  // 程序将立即退出循环
  break()
}

其中，import语句是必须的，它将Scala标准函数库中的breaks函数引入到当前作用域中。breakable函数接受一个代码块作为参数，这个代码块里面应该写循环代码。当循环需要被中断时，可以调用break()函数，程序将在调用该函数的位置立即退出循环。以下是使用breakable实现的两个简单例子：

import scala.util.control.Breaks._

// 例一：当i等于3时退出循环
var i = 0
breakable {
  while (i < 10) {
    i += 1
    if (i == 3) {
      break() // 跳出循环
    }
    println(i)
  }
}

// 例二：查找      个1
val arr = Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
var index = 0
breakable {
  for (i <- arr.indices) {
    if (arr(i) == 1) {
      index = i
      break() // 跳出循环
    }
  }
}
println(index)

以上两个例子都展示了breakable函数的基本用法。接下来，我们将更深入地了解breakable的一些高级用法。

1. breakable嵌套

当循环嵌套时，breakable也可以嵌套使用，这样可以在一个内层循环中跳出外层循环。下面是一个例子，其中breakable嵌套在while循环与for循环中：

import scala.util.control.Breaks._

val arr = Array(Array(1, 2), Array(3, 4))
var found = false
breakable {
  for (i <- arr.indices) {
    val subArr = arr(i)
    breakable {
      for (j <- subArr.indices) {
        if (subArr(j) == 4) {
          found = true
          break()
        }
      }
    }
  }
}
println(found)

在上面的例子中，我们要查找元素4在外层数组arr中的哪个位置。我们通过一个外层循环和一个内层循环遍历该数组，并使用breakable跳出循环。当元素4被发现时，我们设置found标志为true，并在breakable代码块中调用break方法，从而退出内层循环。

2. breakable带返回值

breakable方法在退出循环时可以带一个返回值，这个值可以在调用breakable方法的地方直接使用。下面是一个示例，其中我们要查找一个字符串数组中 个包含“world”的字符串，并返回其索引值：

import scala.util.control.Breaks._

def findFirstWorldIndex(strs: Array[String]): Int = {
  var index = -1
  breakable {
    for (i <- strs.indices) {
      if (strs(i).contains("world")) {
        index = i
        break()
      }
    }
  }
  index
}
val strs = Array("hello", "world", "scala", "java")
val index = findFirstWorldIndex(strs)
println(index)

在上面的例子中，我们编写了一个名为findFirstWorldIndex的方法，接受一个字符串数组作为参数，返回包含“world”的字符串的 个索引。我们使用breakable定义了一个代码块，在其中执行循环操作。当找到相应字符串时，我们使用break方法跳出循环，并将找到的索引值保存在变量index中。

3. 带标签的breakable

在Scala中，标签是一种方便的机制，可以在breakable方法中标记某个代码块，当程序执行到某个位置时，可以从外层代码跳出到这个标记位置处。如果要在内层循环中跳出外层循环，可以使用带标签的breakable方法。下面是一个例子：

import scala.util.control.Breaks._

val outerArr = Array(Array(1, 2), Array(3, 4))
val innerArr = Array(Array(5, 6), Array(7, 8))
var found = false
outer@ breakable {
  for (i <- outerArr.indices) {
    val subArr = outerArr(i)
    inner@ breakable {
      for (j <- subArr.indices) {
        if (subArr(j) == 4) {
          found = true
          break(outer)
        }
      }
    }
    if (found) {
      break(outer)
    }
    println("outer")
  }
  println("end of outer")
}
inner@ breakable {
  for (i <- innerArr.indices) {
    val subArr = innerArr(i)
    for (j <- subArr.indices) {
      if (subArr(j) == 8) {
        found = true
        break(inner)
      }
    }
  }
  println("inner")
}
println(found)

在上面的例子中，我们定义了一个内层数组innerArr和外层数组outerArr。我们使用了两个带标签的breakable方法：outer和inner。在outer方法中，我们使用循环遍历outerArr和其子数组，并在找到元素4时跳出外层循环。同样地，在inner方法中，我们使用循环遍历innerArr，并在找到元素8时跳出循环。这两个方法都被标记了标签，用于在break方法中区分跳出循环的是外层循环还是内层循环。在代码的结尾处，我们打印found变量的值以确认找到了相应的元素。