scala Iterable # map vs. Iterable # flatMap

Question

Qual è la differenza tra le funzioni map e flatMap di Iterable?

Answer 1

Ecco una buona spiegazione:

http://www.codecommit.com/blog/scala/scala-collections-for-the-easily-bored-part-2

Utilizzando lista come esempio: firma

del Map è:

map [B](f : (A) => B) : List[B] 

e flatMap di è

flatMap [B](f : (A) => Iterable[B]) : List[B] 

Quindi flatMap accetta un tipo [A] e restituisce un tipo iterabile [B] e mappa assume un tipo [A] e restituisce un tipo [B]

Questo ti darà anche un'idea che flatmap si "appiattirà" elenchi.

val l = List(List(1,2,3), List(2,3,4)) 

println(l.map(_.toString)) // changes type from list to string 
// prints List(List(1, 2, 3), List(2, 3, 4)) 

println(l.flatMap(x => x)) // "changes" type list to iterable 
// prints List(1, 2, 3, 2, 3, 4) 

Answer 2

Da scaladoc:

• mappa

restituisce iterable risultante dall'applicazione della funzione data f per ogni elemento di questo iterabile.

• flatMap

applica la funzione data f a ciascun elemento di questo iterabile, quindi concatena i risultati.

Answer 3

Guardate qui: http://www.codecommit.com/blog/scala/scala-collections-for-the-easily-bored-part-2

"Cerca flatMap" - c'è davvero una buona spiegazione di lì. (Fondamentalmente si tratta di una combinazione di "appiattimento" e "mappa" - caratteristiche di altre lingue).

Answer 4

Quanto sopra è tutto vero, ma c'è una cosa che è a portata di mano: flatMap trasforma un List[Option[A]] in List[A], con qualsiasi Option che entra in profondità per None, rimosso. Questa è una svolta concettuale chiave per andare oltre l'utilizzo di null.

Answer 5

lines.map(line => line split "\\W+") // will return a list of arrays of words 
lines.flatMap(line => line split "\\W+") // will return a list of words 

si può vedere questo meglio in espressioni for:

for {line <- lines 
    word <- line split "\\W+"} 
yield word.length 

questo si traduce in:

lines.flatMap(line => line.split("\\W+").map(word => word.length)) 

Ogni iteratore all'interno per sarà tradotto in un "flatMap", tranne l'ultimo uno, che viene tradotto in una "mappa".In questo modo, invece di restituire le raccolte nidificate (una lista di una matrice di un buffer di blah, blah, blah), si restituisce una collezione piatta. Una raccolta formata dagli elementi che vengono resi: una lista di interi, in questo caso.