Effiziente Iteration mit Index in Scala

Da Scala keine alten Java- forSchleifen mit Index hat,

// does not work
val xs = Array("first", "second", "third")
for (i=0; i<xs.length; i++) {
  println("String #" + i + " is " + xs(i))
}

Wie können wir effizient und ohne Verwendung von vars iterieren ?

Du könntest das tun

val xs = Array("first", "second", "third")
val indexed = xs zipWithIndex
for (x <- indexed) println("String #" + x._2 + " is " + x._1)

Die Liste wird jedoch zweimal durchlaufen - nicht sehr effizient.

Viel schlimmer als zweimaliges Durchlaufen, erzeugt es ein Zwischenarray von Paaren. Sie können verwenden view. Wenn Sie dies tun collection.view, können Sie sich nachfolgende Anrufe als träge während der Iteration vorstellen. Wenn Sie eine ordnungsgemäß vollständig realisierte Sammlung zurückerhalten möchten, rufen Sie forceam Ende an. Hier wäre das nutzlos und teuer. Ändern Sie also Ihren Code in

for((x,i) <- xs.view.zipWithIndex) println("String #" + i + " is " + x)

Es wurde erwähnt , dass Scala tut haben Syntax für forSchleifen:

for (i <- 0 until xs.length) ...

oder einfach

for (i <- xs.indices) ...

Sie haben jedoch auch nach Effizienz gefragt. Es stellt sich heraus , dass die Scala forSyntax höherer Ordnung Methoden wie eigentlich syntaktischer Zucker ist map, foreachusw. Als solche in einigen Fällen diese Schleifen kann ineffizient sein, zB Wie optimize for-Comprehensions und Schleifen in Scala?

(Die gute Nachricht ist, dass das Scala-Team daran arbeitet, dies zu verbessern. Hier ist das Problem im Bug-Tracker: https://issues.scala-lang.org/browse/SI-4633 )

Um ein Höchstmaß an Effizienz zu erzielen, können Sie eine whileSchleife oder, wenn Sie darauf bestehen, die Verwendung von zu verwenden var, die Schwanzrekursion verwenden:

import scala.annotation.tailrec

@tailrec def printArray(i: Int, xs: Array[String]) {
  if (i < xs.length) {
    println("String #" + i + " is " + xs(i))
    printArray(i+1, xs)
  }
}
printArray(0, Array("first", "second", "third"))

Beachten Sie, dass die optionale @tailrec Annotation hilfreich ist, um sicherzustellen, dass die Methode tatsächlich rekursiv ist. Der Scala-Compiler übersetzt rekursive Aufrufe in den Bytecode, der while-Schleifen entspricht.

Noch ein Weg:

scala> val xs = Array("first", "second", "third")
xs: Array[java.lang.String] = Array(first, second, third)

scala> for (i <- xs.indices)
     |   println(i + ": " + xs(i))
0: first
1: second
2: third

Tatsächlich hat Scala alte Java-Schleifen mit Index:

scala> val xs = Array("first","second","third")
xs: Array[java.lang.String] = Array(first, second, third)

scala> for (i <- 0 until xs.length)
     | println("String # " + i + " is "+ xs(i))

String # 0 is first
String # 1 is second
String # 2 is third

Wobei 0 until xs.lengthoder 0.until(xs.length)ist eine RichIntMethode, die Rangefür eine Schleife geeignet ist.

Sie können auch versuchen, Schleife mit to:

scala> for (i <- 0 to xs.length-1)
     | println("String # " + i + " is "+ xs(i))
String # 0 is first
String # 1 is second
String # 2 is third

Wie wäre es damit?

val a = Array("One", "Two", "Three")
a.foldLeft(0) ((i, x) => {println(i + ": " + x); i + 1;} )

Ausgabe:

0: One
1: Two
2: Three

Das Einlaufen in Scala ist ziemlich einfach. Erstellen Sie beispielsweise ein Array Ihrer Wahl.

val myArray = new Array[String](3)
myArray(0)="0";
myArray(1)="1";
myArray(2)="2";

Arten von Schleifen,

for(data <- myArray)println(data)

for (i <- 0 until myArray.size)
println(i + ": " + myArray(i))

Wenn Sie zipWithIndexeine Sammlung aufrufen, wird diese durchlaufen und eine neue Sammlung für die Paare erstellt. Um dies zu vermeiden, können Sie einfach zipWithIndexden Iterator für die Sammlung aufrufen . Dadurch wird nur ein neuer Iterator zurückgegeben, der den Index während der Iteration verfolgt, ohne dass eine zusätzliche Sammlung oder ein zusätzliches Durchlaufen erstellt werden muss.

So wird scala.collection.Iterator.zipWithIndexderzeit in 2.10.3 implementiert:

  def zipWithIndex: Iterator[(A, Int)] = new AbstractIterator[(A, Int)] {
    var idx = 0
    def hasNext = self.hasNext
    def next = {
      val ret = (self.next, idx)
      idx += 1
      ret
    }
  }

Dies sollte sogar etwas effizienter sein als das Erstellen einer Ansicht für die Sammlung.

Es gibt nichts in der stdlib, was es für Sie tun könnte, ohne Tupelmüll zu erzeugen, aber es ist nicht zu schwer, Ihren eigenen zu schreiben. Leider habe ich mich nie darum gekümmert, herauszufinden, wie man die richtige implizite CanBuildFrom-Raindance ausführt, um solche Dinge in der Art der Sammlung, auf die sie angewendet werden, generisch zu machen, aber wenn es möglich ist, wird uns sicher jemand aufklären. :) :)

def foreachWithIndex[A](as: Traversable[A])(f: (Int,A) => Unit) {
  var i = 0
  for (a <- as) {
    f(i, a)
    i += 1
  }
}

def mapWithIndex[A,B](in: List[A])(f: (Int,A) => B): List[B] = {
  def mapWithIndex0(in: List[A], gotSoFar: List[B], i: Int): List[B] = {
    in match {
      case Nil         => gotSoFar.reverse
      case one :: more => mapWithIndex0(more, f(i, one) :: gotSoFar, i+1)
    }
  }
  mapWithIndex0(in, Nil, 0)
}

// Tests....

@Test
def testForeachWithIndex() {
  var out = List[Int]()
  ScalaUtils.foreachWithIndex(List(1,2,3,4)) { (i, num) =>
    out :+= i * num
  }
  assertEquals(List(0,2,6,12),out)
}

@Test
def testMapWithIndex() {
  val out = ScalaUtils.mapWithIndex(List(4,3,2,1)) { (i, num) =>
    i * num
  }

  assertEquals(List(0,3,4,3),out)
}

Einige weitere Möglichkeiten zum Iterieren:

scala>  xs.foreach (println) 
first
second
third

foreach und ähnliche Karte, die etwas zurückgeben würde (die Ergebnisse der Funktion, die für println Unit ist, also eine Liste von Einheiten)

scala> val lens = for (x <- xs) yield (x.length) 
lens: Array[Int] = Array(5, 6, 5)

arbeite mit den Elementen, nicht mit dem Index

scala> ("" /: xs) (_ + _) 
res21: java.lang.String = firstsecondthird

falten

for(int i=0, j=0; i+j<100; i+=j*2, j+=i+2) {...}

kann mit Rekursion durchgeführt werden:

def ijIter (i: Int = 0, j: Int = 0, carry: Int = 0) : Int =
  if (i + j >= 100) carry else 
    ijIter (i+2*j, j+i+2, carry / 3 + 2 * i - 4 * j + 10) 

Das Carry-Teil ist nur ein Beispiel, um etwas mit i und j zu tun. Es muss kein Int sein.

für einfachere Sachen, näher an üblichen For-Loops:

scala> (1 until 4)
res43: scala.collection.immutable.Range with scala.collection.immutable.Range.ByOne = Range(1, 2, 3)

scala> (0 to 8 by 2)   
res44: scala.collection.immutable.Range = Range(0, 2, 4, 6, 8)

scala> (26 to 13 by -3)
res45: scala.collection.immutable.Range = Range(26, 23, 20, 17, 14)

oder ohne Bestellung:

List (1, 3, 2, 5, 9, 7).foreach (print) 

Ich habe die folgenden Ansätze

object HelloV2 {

   def main(args: Array[String]) {

     //Efficient iteration with index in Scala

     //Approach #1
     var msg = "";

     for (i <- args.indices)
     {
       msg+=(args(i));
     }
     var msg1="";

     //Approach #2
     for (i <- 0 until args.length) 
     {
       msg1 += (args(i));
     }

     //Approach #3
     var msg3=""
     args.foreach{
       arg =>
        msg3 += (arg)
     }


      println("msg= " + msg);

      println("msg1= " + msg1);

      println("msg3= " + msg3);

   }
}

Ein einfacher und effizienter Weg, inspiriert von der Implementierung transformin SeqLike.scala

    var i = 0
    xs foreach { el =>
      println("String #" + i + " is " + xs(i))
      i += 1
    }

Die vorgeschlagenen Lösungen leiden unter der Tatsache, dass sie entweder explizit über eine Sammlung iterieren oder die Sammlung in eine Funktion einfügen. Es ist natürlicher, sich an die üblichen Redewendungen von Scala zu halten und den Index in die üblichen Karten- oder Foreach-Methoden einzufügen. Dies kann durch Auswendiglernen erfolgen. Der resultierende Code könnte so aussehen

myIterable map (doIndexed(someFunction))

Hier ist ein Weg, um diesen Zweck zu erreichen. Betrachten Sie das folgende Dienstprogramm:

object TraversableUtil {
    class IndexMemoizingFunction[A, B](f: (Int, A) => B) extends Function1[A, B] {
        private var index = 0
        override def apply(a: A): B = {
            val ret = f(index, a)
            index += 1
            ret
        }
    }

    def doIndexed[A, B](f: (Int, A) => B): A => B = {
        new IndexMemoizingFunction(f)
    }
}

Das ist schon alles was du brauchst. Sie können dies beispielsweise wie folgt anwenden:

import TraversableUtil._
List('a','b','c').map(doIndexed((i, char) => char + i))

was zu der Liste führt

List(97, 99, 101)

Auf diese Weise können Sie die üblichen Traversable-Funktionen auf Kosten der Umhüllung Ihrer effektiven Funktion verwenden. Genießen!