将Java循环转换为Scala

我正在尝试将选择排序从Java转换为Scala，我不确定如何将此循环转换为Scala：

for (int j = i + 1; j < N; j++)

for（int j=i+1；j

下面是一个更大的Java代码示例及其Scala等价物：

爪哇：

sort(Comparable[] a)
{
int N = a.length;
for (int i = 0; i < N; i++)
{
   int min = i
   for (int j = i + 1; j < N; j++)
}

排序（可比[]a）
{
int N=a.长度；
对于（int i=0；i

斯卡拉：

  def sort(a : Array[Ordered[Any]]) = {
    var N = a.length

    for (i <- 0 until N) {
        var min = i

        for(j <- until j < N){

        }
    }

  }

def排序（a:Array[Ordered[Any]]）={
var N=长度
对于（i给你：

def sort(a : Array[Ordered[Any]]) = {
    val N = a.length

    for (i <- 0 until N) {
        var min = i

        for(j <- i + 1 until N){

        }
    }

  }

def排序（a:Array[Ordered[Any]]）={
val N=a.长度
对于（i不幸的是，Scala上循环的标准速度非常慢（尤其是对于较旧的版本）

另一种选择是经典的while循环，即使它不是很清楚：

  def sort(a : Array[Ordered[Any]]) = {
    val N = a.length

    var i = 0;
    while (i < N) {
        var min = i

        var j = i + 1;
        while (j < N) {
          j += 1;
        }
        i += 1;
    }

}

def排序（a:Array[Ordered[Any]]）={
val N=a.长度
var i=0；
而（i

或尾部递归函数：

  def sort(a : Array[Ordered[Any]]) = {
    val N = a.length

    def l1(i: Int){
      def l2(j: Int, min: Int){
        if (j < N) 
          l2(j+1, min)
      }
      if (i < N) {
         l2(i+1, i);
         l1(i+1);
      }
    }
}

def排序（a:Array[Ordered[Any]]）={
val N=a.长度
def l1（i:Int）{
def l2（j:Int，min:Int）{
if（j

或spire的首席财务官：

  def sort(a : Array[Ordered[Any]]) = {
    val N = a.length

    cfor(0)(_ < N, _ + 1) { i => 
        var min = i
        cfor(i+1)(_ < N, _ + 1) { j => 
        }
    }

}

def排序（a:Array[Ordered[Any]]）={
val N=a.长度
cfor（0）（i=>
var min=i
（i+1）（{j=>
}
}
}
使用for循环（不完全是一种功能性/惯用的scala方式）进行迭代与java代码非常相似。这将帮助您完成

def sort(a: Array[Comparable]) {
  val N = a.length
  for (
    i <- 0 until N;
    min = i;
    j <- (i + 1) until N
  ) {
    // more code..
  }
}

def排序（a:Array[Comparable]）{
val N=a.长度
为了(
我也明白了。@BeniBela by'standard for loops'你包括了“.foreach”吗？
  def sort(a : Array[Ordered[Any]]) = {
    val N = a.length

    cfor(0)(_ < N, _ + 1) { i => 
        var min = i
        cfor(i+1)(_ < N, _ + 1) { j => 
        }
    }

}

def sort(a: Array[Comparable]) {
  val N = a.length
  for (
    i <- 0 until N;
    min = i;
    j <- (i + 1) until N
  ) {
    // more code..
  }
}

sort(Comparable[] a)
{
int N = a.length;
for (int i = 0; i < N; i++)
{
   int min = i
   for (int j = i + 1; j < N; j++)
}