我不知道Scala风格在过去的9年里发生了多大的变化，但我发现一个有趣的现象:大多数现有的答案都使用了var，或者是难以阅读的递归。尽早退出的关键是使用惰性集合生成可能的候选对象，然后分别检查条件。生成产物:

val products = for {
  i <- (999 to 1 by -1).view
  j <- (i to 1 by -1).view
} yield (i*j)

然后在不生成所有组合的情况下从视图中找到第一个回文:

val palindromes = products filter {p => p.toString == p.toString.reverse}
palindromes.head

要找到最大的回文(尽管懒惰不会给你带来什么好处，因为你必须检查整个列表):

palindromes.max

您的原始代码实际上是在检查第一个大于后续产品的回文，这与检查第一个回文是一样的，只是在一个奇怪的边界条件下，我认为这不是您想要的。乘积不是严格单调递减的。例如，998*998大于999*997，但在循环中出现得更晚。

不管怎样，分离的惰性生成和条件检查的优点是，你写它的时候就像使用整个列表一样，但它只生成你需要的东西。你可以说是两全其美了。

巧妙地使用find方法进行收集将为您提供帮助。

var largest = 0
lazy val ij =
  for (i <- 999 to 1 by -1; j <- i to 1 by -1) yield (i, j)

val largest_ij = ij.find { case(i,j) =>
  val product = i * j
  if (product.toString == product.toString.reverse)
    largest = largest max product
  largest > product
}

println(largest_ij.get)
println(largest)

这是一个尾部递归的版本。不可否认，与for推导式相比，它有点晦涩，但我认为它是功能性的:)

def run(start:Int) = {
  @tailrec
  def tr(i:Int, largest:Int):Int = tr1(i, i, largest) match {
    case x if i > 1 => tr(i-1, x)
    case _ => largest
  }

  @tailrec
  def tr1(i:Int,j:Int, largest:Int):Int = i*j match {
    case x if x < largest || j < 2 => largest
    case x if x.toString.equals(x.toString.reverse) => tr1(i, j-1, x)
    case _ => tr1(i, j-1, largest)
  }

  tr(start, 0)
}

如您所见，tr函数是外部for推导式的对应函数，tr1是内部for推导式的对应函数。如果你知道如何优化我的版本，欢迎你。

import scala.util.control._

object demo_brk_963 
{
   def main(args: Array[String]) 
   {
      var a = 0;
      var b = 0;
      val numList1 = List(1,2,3,4,5,6,7,8,9,10);
      val numList2 = List(11,12,13);

      val outer = new Breaks; //object for break
      val inner = new Breaks; //object for break

      outer.breakable // Outer Block
      {
         for( a <- numList1)
         {
            println( "Value of a: " + a);

            inner.breakable // Inner Block
            {
               for( b <- numList2)
               {
                  println( "Value of b: " + b);

                  if( b == 12 )
                  {
                      println( "break-INNER;");
                       inner.break;
                  }
               }
            } // inner breakable
            if( a == 6 )
            {
                println( "break-OUTER;");
                outer.break;
            }
         }
      } // outer breakable.
   }
}

打破循环的基本方法，使用Breaks类。 通过将循环声明为可打破的。

只需使用while循环:

var (i, sum) = (0, 0)
while (sum < 1000) {
  sum += i
  i += 1
}

我遇到了类似下面代码的情况

 for(id<-0 to 99) {
    try {
      var symbol = ctx.read("$.stocks[" + id + "].symbol").toString
      var name = ctx.read("$.stocks[" + id + "].name").toString
      stocklist(symbol) = name
    }catch {
      case ex: com.jayway.jsonpath.PathNotFoundException=>{break}
    }
  }

我正在使用一个java库和机制是ctx。read在找不到任何东西时抛出异常。 我被困在这样的情况中:当抛出异常时，我必须打破循环，但是scala.util.control. break .break使用异常来打破循环，并且它在catch块中，因此它被捕获。

我有一个丑陋的方法来解决这个问题:第一次执行循环，并获得实际长度的计数。 然后用它来做第二个循环。

当你使用一些java库时，从Scala中解脱出来并不是那么好。