Convertit une Chaîne de la liste de la Carte[String, List]

Je suis en train de convertir List("a,1" , "b,2" , "c,3" , "a,2" , "b,4") de type scala.collection.immutable.HashMap[String, java.util.List[String]] avec des valeurs :

a -> 1,2
b -> 2,4
c -> 3

De sorte que chaque clé contient une Liste de ses valeurs.

Voici mon code pour l'instant : 

object ConvertList extends Application {

  var details = new scala.collection.immutable.HashMap[String, java.util.List[String]]

  val strList = List("a,1" , "b,2" , "c,3" , "a,2" , "b,4")

  //Get all values
  val getValue : Function1[String, String] = { a => a.split(",")(1) }
  val allValues : List[String] = strList map getValue

  //get unique values
  val uniqueValues = allValues.toSet[String]

  //Somehow map each unique value to a value in the original List....
  println(uniqueValues)

  println(strList.flatten)
  //userDetails += "1" -> List("a","b",


}

Comment cette conversion peut être effectuée ?

  • êtes-vous rigoureux sur immuable table de hachage?
  • non, je suis juste essayer d'éviter un impératif solution.
InformationsquelleAutor blue-sky | 2013-08-29
  1. 13
    strList.map(s => (s(0).toString,s(2).toString))
       .groupBy(_._1)
       .mapValues(_.map(_._2))

    De sortie : 

    Map[String,List[String]] = Map(b -> List(2, 4), a -> List(1, 2), c -> List(3))
    • Pourriez-vous expliquer s '(0).toString,s(2).toString)' ? Est-ce la cartographie de chaque élément de chaîne à un String,String tuple ?
    • Belle réponse. L'indexation sur la chaîne qui fait vraiment cette solution propre. Avoir un upvote.
    • Oui, c'est la cartographie de chaque chaîne pour le couple ("la première lettre", "troisième lettre"). (donc,", 1" ("un","1")). Vous pouvez (et doit-il ce code est bien plus qu'un teaser de cerveau) code d'une fonction formatString(s) et utilisez strList.carte(formatString).groupBy(...) pour mieux gérer les cas particuliers (chaîne de caractères.longueur < 3, etc)
    InformationsquelleAutor Marth
  2. 3

    Listes ne serait pas dans le même ordre, mais en général, il est tout à fait faisable problème:

    //for a sake of pithiness
type M = Map[String,List[String]] 
def empty: M = Map.empty.withDefaultValue(Nil)

@annotation.tailrec
def group(xs: List[String], m: M = empty): M = xs match {
    case Nil     => m
    case h::tail => 
      val Array(k,v) = h.split(",")
      val updated = v::m(k)
      combine(tail, m + (k -> updated))
}
    InformationsquelleAutor om-nom-nom
  3. 3

    Il y a déjà une bonne partie de la prend, mais que penser de quelque chose de similaire à ce que Marth propose:

    import scala.collection.JavaConverters._

val strList = List("a,1" , "b,2" , "c,3" , "a,2" , "b,4")

strList.map(_.split(',')).collect { 
  case Array(key, value) => key -> value 
}.groupBy(_._1).mapValues(_.map(_._2).asJava)

    Cela repose fortement sur la programmation fonctionnelle, et se termine avec un Map de type Map[String, java.util.List[String]], tout n'est pas juste de prendre des positions fixes dans la chaîne d'entrée, mais des fentes à la virgule (imaginez d'avoir un nombre de plus de 9, nécessitant plus d'un chiffre).

    Aussi, si il y a plus d'une valeur à partir de la scission, le collect méthode des filtres loin.

    InformationsquelleAutor Jens Egholm
  4. 1
    scala> List("a,1" , "b,2" , "c,3" , "a,2" , "b,4")
res0: List[String] = List(a,1, b,2, c,3, a,2, b,4)

scala> res0.groupBy(xs => xs.split(",")(0)).mapValues(xs => xs.flatMap(xs => xs.toCharArray.filter(_.isDigit)))
res2: scala.collection.immutable.Map[String,List[Char]] = Map(b -> List(2, 4), a -> List(1, 2), c -> List(3))

    À l'aide de groupBy fait de ce droit de l'avant, puisque vous voulez un Map. Le groupBy divise chaque élément de la List par , et prend la première qui est la clé. Qui donne ceci:
    scala.collection.immutable.Map[String,List[String]] = Map(b -> List(b,2, b,4), a -> List(a,1, a,2), c -> List(c,3)). De là, il est juste de traitement pour obtenir les chiffres de chaque List de valeurs.

    Cela renvoie une Map[String, List[Char]]. Il y a un peu plus de travail à faire si vous voulez scala.collection.immutable.HashMap[String, java.util.List[String]] retourné, mais c'est la partie facile.

    InformationsquelleAutor Brian
  5. 0

    De départ Scala 2.13, nous pouvons utiliser la nouvelle groupMap méthode qui (comme son nom l'indique) est un passe-équivalent d'un groupBy et un mapping sur des éléments groupés:

    //val strList = List("a,1" , "b,2" , "c,3" , "a,2" , "b,4")
strList.map(_.split(",")).groupMap(_(0))(_(1))
//Map("b" -> List(2, 4), "a" -> List(1, 2), "c" -> List(3))

    Ce:

    • divise chaque chaîne (production de List(Array(a, 1), Array(b, 2), ...))

    • groups des éléments basés sur leur première partie (_(0)) (groupe de partie de groupeCarte)

    • maps groupées des éléments de leur deuxième partie (_(1)) (carte de la partie de groupe deCarte)

    InformationsquelleAutor Xavier Guihot