Scala: Comment convertir des éléments de tuple en listes

Supposons que j'ai une liste de tuples:

val tuples = listOfStrings.map(string => {
            val split = string.split(":")
            (split(0), split(1), split(2))
        })

Je voudrais obtenir le split(0) dans une liste, split(1) dans une autre liste, et ainsi de suite.
Un moyen simple de ce qui pourrait être atteint par l'écriture:

list1 = tuples.map(x => x._1).toList
list2 = tuples.map(x => x._2).toList
list3 = tuples.map(x => x._3).toList

Est-il plus élégant (fonctionnelle) de manière à atteindre le plus haut, sans écrit 3 états distincts?

source d'informationauteur

  1. 11

    Cela vous donnera le résultat que d'une liste de liste:

    tuples.map{t => List(t._1, t._2, t._3)}.transpose

    Si vous souhaitez les stocker dans des variables locales, il suffit de faire:

    val List(l1,l2,l3) = tuples.map{t => List(t._1, t._2, t._3)}.transpose

    Mise à JOUR: Comme indiqué par Blaisorblade, de la bibliothèque standard a en fait une méthode intégrée pour cela: unzip3ce qui est juste comme unzip mais pour les triples au lieu de paires:

    val (l1, l2, l3) = tuples.unzip3

    Inutile de dire, vous devriez préférer cette méthode sur mon roulé à la main de la solution ci-dessus (mais pour les n-uplets d'arité > 3, ce serait encore s'appliquer).

  2. 10

    Vous voulez décompresser:

    scala> val (numbers, homonyms) = List(("one", "won"), ("two", "too")).unzip
numbers: List[java.lang.String] = List(one, two)
homonyms: List[java.lang.String] = List(won, too)
  3. 3

    Si vous voulez quelque chose qui peut être utilisé pour arbitraire tuple tailles:

    val tupleSize = 3
0.until(tupleSize).toList
    .map(x => (_:Product).productElement(x).asInstanceOf[String])
    .map(tuples.map(_))

    De toute évidence, cela pourrait être exprimé de manière plus élégante si vous aviez une Liste de Tableaux à la place.

  4. 1

    Vous pouvez simplement écrire les déclarations en une seule ligne.

    Comme

     (list1, list2, list3) = tuples.foldRight((List[String](), List[String](), List[String]()))( (a,b) => (a._1 :: b._1, a._2 :: b._2, a._3 :: b._3 ) )
  5. 0

    Je ne sais pas élégant, mais vous pourrait le faire en une seule ligne sans l'étape intermédiaire de stocker les n-uplets. C'est peut-être un peu dur à lire...

    (for(split <- listOfStrings.map(_.split(":")))
  yield List(split(0), split(1), split(2))).transpose

    repl exemple:

    scala> listOfStrings
res1: List[java.lang.String] = List(a:b:c, d:e:f, g:h:i)

scala> (for(split <- listOfStrings.map(_.split(":")))
     |   yield List(split(0), split(1), split(2))).transpose
res2: List[List[java.lang.String]] = List(List(a, d, g), List(b, e, h), List(c, f, i))