Scala: Der beste Weg zu filtern & Karte in einer Iteration

Question

Ich bin neu in Scala und versuchen, die beste Art und Weise, um herauszufinden, zu filtern & eine Sammlung Karte. Hier ist ein Spielzeugbeispiel, um mein Problem zu erklären.

Ansatz 1: Das ist ziemlich schlecht, da ich zweimal durch die Liste iteriere und den gleichen Wert in jeder Iteration berechne.

val N = 5 
val nums = 0 until 10 
val sqNumsLargerThanN = nums filter { x: Int => (x * x) > N } map { x: Int => (x * x).toString } 

Ansatz 2: Dies ist etwas besser, aber ich muss noch (x * x) zweimal berechnen.

Also, ist es möglich, dies zu berechnen, ohne zweimal durch die Sammlung zu iterieren und die gleichen Berechnungen zu vermeiden?

Answer 1

können Sie collect verwenden, die zu jedem Wert der Sammlung eine Teilfunktion gilt, dass sie in bestimmten ist. Ihr Beispiel könnte wie folgt geschrieben werden:

val sqNumsLargerThanN = nums collect { 
    case (x: Int) if (x * x) > N => (x * x).toString 
} 

Answer 2

Der typische Ansatz ist es, ein iterator (wenn möglich) oder view zu verwenden (wenn iterator wird nicht funktionieren). Dies gilt nicht genau zwei Überquerungen vermeiden, aber es tut Schaffung einer Full-Size-Zwischen Sammlung zu vermeiden. Sie dann map erste und filter danach und dann map wieder, wenn nötig:

xs.iterator.map(x => x*x).filter(_ > N).map(_.toString) 

Der Vorteil dieses Ansatzes ist, dass es wirklich einfach ist und zu lesen, da es keine Zwischen Sammlungen sind, ist es einigermaßen effizient ist.

Wenn Sie fragen, denn dies ist eine Performance-Engpass ist, dann ist die Antwort in der Regel eine Schwanz-rekursive Funktion oder verwenden Sie den alten Stil while-Schleife-Methode zu schreiben. Zum Beispiel, in Ihrem Fall

def sumSqBigN(xs: Array[Int], N: Int): Array[String] = { 
    val ysb = Array.newBuilder[String] 
    def inner(start: Int): Array[String] = { 
    if (start >= xs.length) ysb.result 
    else { 
     val sq = xs(start) * xs(start) 
     if (sq > N) ysb += sq.toString 
     inner(start + 1) 
    } 
    } 
    inner(0) 
} 

Sie können auch einen Parameter vorwärts in inner anstelle der Verwendung eines externen Builder (besonders nützlich für Summen) übergeben.

Answer 3

Könnte ein foldRight

nums.foldRight(List.empty[Int]) { 
    case (i, is) => 
    val s = i * i 
    if (s > N) s :: is else is 
    } 

A verwenden foldLeft erreichen würde auch ein ähnliches Ziel, aber die resultierende Liste in umgekehrter Reihenfolge (aufgrund der Assoziativität von foldLeft.

Alternativ wäre, wenn du würdest gerne mit Scalaz spielen

import scalaz.std.list._ 
import scalaz.syntax.foldable._ 

nums.foldMap { i => 
    val s = i * i 
    if (s > N) List(s) else List() 
} 

Answer 4

Ein sehr einfacher Ansatz, der nur die Multiplikation durchführt o nce. Es ist auch faul, so wird es nur seine Ausführung von Code, wenn nötig.

nums.view.map(x=>x*x).withFilter(x => x> N).map(_.toString) 

Werfen Sie einen Blick here für Unterschiede zwischen filter und withFilter.

Answer 5

Ich habe noch zu bestätigen, dass dies wirklich ein einziger Durchgang, aber:

val sqNumsLargerThanN = nums flatMap { x => 
    val square = x * x 
    if (square > N) Some(x) else None 
    } 

Answer 6

das Betrachten Sie zum Verständnis,

for (x <- 0 until 10; v = x*x if v > N) yield v.toString 

die zu einem flatMap über den Bereich entfaltet und ein (faul) withFilter auf das einmal berechnete Quadrat und ergibt eine Sammlung mit gefilterten Ergebnissen. Es ist erforderlich, eine Iteration und eine Berechnung des Quadrats zu notieren (zusätzlich zum Erstellen des Bereichs).

Answer 7

Sie können flatMap verwenden.

val sqNumsLargerThanN = nums flatMap { x => 
    val square = x * x 
    if (square > N) Some(square.toString) else None 
} 

Oder mit Scalaz,

import scalaz.Scalaz._ 

val sqNumsLargerThanN = nums flatMap { x => 
    val square = x * x 
    (square > N).option(square.toString) 
} 

---

Das löst die gestellte Frage, wie diese mit einer Iteration zu tun. Dies kann nützlich sein, wenn Daten wie mit einem Iterator gestreamt werden.

Allerdings ... wenn Sie stattdessen wollen die absolute schnellste Implementierung, das ist es nicht. Tatsächlich vermute ich, dass Sie eine veränderbare ArrayList und eine while-Schleife verwenden würden. Aber erst nach dem Profiling würden Sie es sicher wissen. Auf jeden Fall ist das für eine andere Frage.

Answer 8

ein für das Verständnis Verwendung funktionieren würde:

val sqNumsLargerThanN = for {x <- nums if x*x > N } yield (x*x).toString 

Auch ich bin nicht sicher, aber ich denke, die scala Compiler über einen Filter vor einer Karte smart ist und tun nur 1 Durchgang, wenn möglich.

Answer 9

ich auch tat es Anfänger als

for(y<-(num.map(x=>x*x)) if y>5) { println(y)}