Scala - Converti Lista di liste in una singola Lista: Lista [Lista [A]] in Lista [A]

Question

Qual è il modo migliore per convertire una Lista di liste in scala (2.9)?

Ho una lista:

List[List[A]] 

che voglio convertire in

List[A] 

Come può essere raggiunto in modo ricorsivo? O c'è un altro modo migliore?

Answer 1

L'elenco ha il metodo di appiattimento. Perché non usarlo?

List(List(1,2), List(3,4)).flatten 
> List(1,2,3,4) 

Answer 2

Dato l'esempio precedente, non sono sicuro che sia necessario ricorrere. Sembra che tu voglia List.flatten invece.

ad es.

scala> List(1,2,3) 
res0: List[Int] = List(1, 2, 3) 

scala> List(4,5,6) 
res1: List[Int] = List(4, 5, 6) 

scala> List(res0,res1) 
res2: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6)) 

scala> res2.flatten 
res3: List[Int] = List(1, 2, 3, 4, 5, 6) 

Answer 3

.flatten è ovviamente il modo più semplice, ma per completezza si dovrebbe anche sapere su flatMap

val l = List(List(1, 2), List(3, 4)) 
println(l.flatMap(identity)) 

e la for-comprensione equivalente

println(for (list <- l; x <- list) yield x) 

appiattire è ovviamente un caso speciale di flatMap, che può fare molto di più.

Answer 4

Non hai bisogno di ricorsione, ma è possibile utilizzarlo se si vuole:

def flatten[A](list: List[List[A]]):List[A] = 
    if (list.length==0) List[A]() 
    else list.head ++ flatten(list.tail) 

Questo funziona come metodo di appiattire costruire in lista. Esempio:

scala> flatten(List(List(1,2), List(3,4))) 
res0: List[Int] = List(1, 2, 3, 4) 

Answer 5

Se la struttura può essere ulteriormente annidati, come:

List(List(1, 2, 3, 4, List(5, 6, List(7, 8)))) 

Questa funzione dovrebbe darvi il risultato desiderio:

def f[U](l: List[U]): List[U] = l match { 
    case Nil => Nil 
    case (x: List[U]) :: tail => f(x) ::: f(tail) 
    case x :: tail => x :: f(tail) 
} 

Answer 6

Se si desidera utilizzare flatmap, qui è la via

Supponiamo di avere una lista di lista [Int] di nome ll, e di appiattirla in lista, molte persone già ti danno le risposte, come ad esempio appiattito, questo è il modo semplice. Presumo che tu stia chiedendo di usare il metodo flatmap. Se è il caso, qui è il modo

ll.flatMap(_.map(o=>o))