Cleaner Tupel groupBy

Habe ich eine Folge von Schlüssel-Wert-Paare (String, Int), und ich will diese Gruppe von Schlüssel in einer Reihenfolge der Werte (D. H. Seq[(String, Int)]) => Map[String, Iterable[Int]])).

Offensichtlich toMap ist nicht sinnvoll hier, und groupBy unterhält die Werte als Tupel. Die besten habe ich es geschafft zu kommen mit ist:

val seq: Seq[( String, Int )]
//...
seq.groupBy( _._1 ).mapValues( _.map( _._2 ) )

Gibt es eine bessere Möglichkeit, dies zu tun?

  • +1 Verwenden Sie diese Muster so oft ich wünschte, es wurde etwas gebaut.
InformationsquelleAutor Tomer Gabel | 2012-05-28
  1. 19

    Hier ist ein Zuhälter, fügt eine toMultiMap Methode traversables. Würde es dein problem lösen?

    import collection._
import mutable.Builder
import generic.CanBuildFrom

class TraversableOnceExt[CC, A](coll: CC, asTraversable: CC => TraversableOnce[A]) {

  def toMultiMap[T, U, That](implicit ev: A <:< (T, U), cbf: CanBuildFrom[CC, U, That]): immutable.Map[T, That] =
    toMultiMapBy(ev)

  def toMultiMapBy[T, U, That](f: A => (T, U))(implicit cbf: CanBuildFrom[CC, U, That]): immutable.Map[T, That] = {
    val mutMap = mutable.Map.empty[T, mutable.Builder[U, That]]
    for (x <- asTraversable(coll)) {
      val (key, value) = f(x)
      val builder = mutMap.getOrElseUpdate(key, cbf(coll))
      builder += value
    }
    val mapBuilder = immutable.Map.newBuilder[T, That]
    for ((k, v) <- mutMap)
      mapBuilder += ((k, v.result))
    mapBuilder.result
  }
}

implicit def commomExtendTraversable[A, C[A] <: TraversableOnce[A]](coll: C[A]): TraversableOnceExt[C[A], A] =
  new TraversableOnceExt[C[A], A](coll, identity)

    Kann z.B. so verwendet werden:

    val map = List(1 -> 'a', 1 -> 'à', 2 -> 'b').toMultiMap
println(map)  //Map(1 -> List(a, à), 2 -> List(b))

val byFirstLetter = Set("abc", "aeiou", "cdef").toMultiMapBy(elem => (elem.head, elem))
println(byFirstLetter) //Map(c -> Set(cdef), a -> Set(abc, aeiou))

    Wenn Sie fügen Sie die folgende implizite defs, es wird auch mit Inkasso-ähnliche Objekte wie Strings und Arrays:

    implicit def commomExtendStringTraversable(string: String): TraversableOnceExt[String, Char] =
  new TraversableOnceExt[String, Char](string, implicitly)

implicit def commomExtendArrayTraversable[A](array: Array[A]): TraversableOnceExt[Array[A], A] =
  new TraversableOnceExt[Array[A], A](array, implicitly)

    Dann:

    val withArrays = Array(1 -> 'a', 1 -> 'à', 2 -> 'b').toMultiMap
println(withArrays) //Map(1 -> [C@377653ae, 2 -> [C@396fe0f4)

val byLowercaseCode = "Mama".toMultiMapBy(c => (c.toLower.toInt, c))
println(byLowercaseCode) //Map(97 -> aa, 109 -> Mm)
    • Viel mehr, als ich erwartet hatte, aber dennoch nützlich. Danke!
    • Das ist sehr schön. Gibt es da eine einfache Möglichkeit zum überschreiben der Typ des Werte-Sammlung (wie ich eine List(1 -> 'a', 1 -> 'à', 2 -> 'b'), aber ich will das Ergebnis toMultiMap zu Map[Int, Set[String]] ? Einige trick mit breakOut vielleicht?
    InformationsquelleAutor Jean-Philippe Pellet
  2. 12

    Gibt es keine Methode oder der Struktur der Daten in der standard-Bibliothek, dies zu tun, und deine Lösung sieht in etwa so präzise, wie Sie bekommen. Wenn Sie diese in mehr als einem Ort, möchten Sie vielleicht, um Sie Faktor in einer utility-Methode

    def groupTuples[A,B](seq: Seq[(A,B)]) = 
  seq groupBy (_._1) mapValues (_ map (_._2))

    dem Sie dann offensichtlich einfach anrufen mit groupTuples(seq). Dies möglicherweise nicht die effizienteste im Hinblick auf CPU-Taktzyklen, aber ich glaube nicht, dass es besonders ineffiziente entweder.

    Habe ich eine grobe benchmark gegen Jean-Philippe Lösung auf eine Liste mit 9 Tupeln und dies ist geringfügig schneller. Beide waren etwa doppelt so schnell als Faltung der Sequenz in eine Karte (effektiv re-Implementierung groupBy zu geben, die Ausgabe, die Sie wollen).

    • mapValues eigentlich nur umschließt die integrierte Karte, so dass es möglicherweise weniger effizient, wenn man die Dinge in der Karte. Außerdem hab ich bearbeitet meine Antwort zu vermeiden toMap; würden Sie mir (aus Neugier) mit dem gleichen benchmark nochmal? Mit 9 Tupeln, Bau die Karte ein und zwei lookups ist etwa ein Drittel schneller mit meinem Vorschlag nach meinen benchmarks.
    • Ich bin immer 97ms für 100k läuft für die oben genannten, und 106ms mit Ihrem neuen ein. Natürlich, wir sollten wirklich versuchen andere Liste mit Längen-und Kompositionen, aber ich wollte nur um eine grobe Idee. In praktischer Hinsicht sind Sie die gleiche Geschwindigkeit.
    • Interessantes über mapValues einwickeln der vorhandenen Karte - ich wusste nicht, dass. Es entsteht eine völlig neue Karte mit seq groupBy (_._1) map (x => (x._1, x._2 map (_._2))) dauert 165 ms, so dass für das erstellen einer neuen map im Speicher deiner ist schneller.
    • Effizienz war eigentlich nicht eine große Sorge, aber es ist schön zu wissen, dass der Effekt unabhängig. Es ist eine Schande, dass ich nicht akzeptieren kann, dass zwei Antworten - ich werde gehen mit Jean-Philippe Antwort, einfach aus dem Grund, dass es so umfangreich 🙂
    InformationsquelleAutor Luigi Plinge
  3. 8

    Ich weiß nicht, ob Sie denken, dass es cleaner:

    seq.groupBy(_._1).map { case (k,v) => (k,v.map(_._2))}
    • Ich weiß nicht, wirklich. War auf der Suche für ein präziseres und/oder semantisch klare Lösung.
    • Sicher. Ich denke, Sie müssen eine Funktion erstellen, und nennen Sie es, wenn nötig. so können Sie die syntax, wie Sie wollen.
    InformationsquelleAutor Johnny Everson
  4. 0

    Ab Scala 2.13 meisten Sammlungen sind mit der groupMap Methode, die (wie der name schon sagt) einen Gegenwert (effizienter) ein groupBy gefolgt von mapValues:

    List(1 -> 'a', 1 -> 'b', 2 -> 'c').groupMap(_._1)(_._2)
//Map[Int,List[Char]] = Map(2 -> List(c), 1 -> List(a, b))

    Diese:

    • groups-Elemente, basierend auf dem ersten Teil von Tupeln (Map(2 -> List((2,c)), 1 -> List((1,a), (1,b))))

    • maps gruppierte Werte ( List((1,a), (1,b)) ), indem Sie Ihre zweite Tupel Teil (List(a, b)).

    InformationsquelleAutor Xavier Guihot
Schreibe einen Kommentar