Scala: Najlepszy sposób filtrowania i mapowania w jednej iteracji

Question

Jestem nowy w Scali i próbuję wymyślić najlepszy sposób filtrowania & mapować kolekcję. Oto zabawny przykład wyjaśniający mój problem.

Podejście 1: Jest to bardzo źle, ponieważ I iteracji poprzez listę dwa razy i obliczania tej samej wartości w każdej iteracji.

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

Podejście 2: Jest to nieco lepiej, ale nadal trzeba obliczyć (x * x) dwukrotnie.

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

Tak, jest to możliwe do obliczenia tego bez iteracja kolekcji dwa razy i uniknąć powtarzania tych samych obliczeń?

Answer 1

Można użyć collect który dotyczy częściowego funkcję do każdej wartości kolekcji, która jest zdefiniowana w. Twój przykład może być przepisana następująco:

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

Answer 2

Typowym rozwiązaniem jest użyć iterator (jeśli to możliwe) lub view (jeśli iterator nie będzie działać). To nie wymaga dwóch przechyleń, ale pozwala uniknąć utworzenia pełnowymiarowego zbioru pośredniego. Następnie map pierwszy i filter potem a następnie map ponownie w razie potrzeby:

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

Zaletą tego podejścia jest to, że jest to naprawdę łatwe do odczytania, a ponieważ nie istnieją zbiory pośrednie, to dość skuteczny.

Jeśli proszą, bo to jest wąskim gardłem wydajności, to odpowiedź jest zazwyczaj napisać funkcję ogon rekurencyjnej lub używać starego stylu while metodą pętli. Na przykład, w przypadku

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) 
} 

Można również przekazać parametr do przodu w inner zamiast przy użyciu konstruktora zewnętrznego (szczególnie przydatnych dla sum).

Answer 3

przydałby się foldRight

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

foldLeft również osiągnąć podobny cel, ale uzyskany lista byłaby w odwrotnej kolejności (z powodu skojarzeń z foldLeft.

Ewentualnie gdybyś Lubi grać ze Scalazem

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

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

Answer 4

Bardzo proste podejście, które wykonuje tylko operację multiplikacji o nce. Jest również leniwy, więc będzie wykonywać kod tylko wtedy, gdy będzie potrzebny.

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

Spójrz here różnice między filter i withFilter.

Answer 5

mam jeszcze potwierdzić, że jest to naprawdę jeden karnet, ale:

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

Answer 6

Rozważ to do zrozumienia,

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

który rozwija do flatMap całym zakresie oraz (leniwy) withFilter na jedyny raz obliczony kwadrat i daje kolekcję z filtrowanymi wynikami. Uwaga: wymagana jest jedna iteracja i jedno obliczenie kwadratu (oprócz tworzenia zakresu).

Answer 7

Można użyć flatMap.

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

Albo z Scalaz,

import scalaz.Scalaz._ 

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

---

rozwiązuje zadawane pytanie, jak to zrobić z jednej iteracji. Może to być przydatne podczas przesyłania strumieniowego danych, jak w przypadku Iteratora.

Jednak ... jeśli chcesz zamiast tego absolutnej implementacji , to nie jest to. W rzeczywistości podejrzewam, że używałbyś zmiennego ArrayList i pętli while. Ale czy po profilowaniu wiesz na pewno. W każdym razie to kolejne pytanie.

Answer 8

Używanie do zrozumienia będzie działać:

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

Ponadto, nie jestem pewien, ale myślę, że kompilator Scala jest mądry o filtrze przed mapą i zrobi 1 podaje tylko, jeśli to możliwe.

Answer 9

Jestem również początkujący zrobił to następująco

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