Comment puis-je convertir immuable.Carte à mutables.Carte en Scala?

Comment puis-je convertir immuable.Carte à mutables.Carte en Scala afin que je puisse mettre à jour les valeurs dans la Carte?

InformationsquelleAutor | 2011-02-18
  1. 121

    La façon la plus propre serait d'utiliser la mutable.Map varargs usine. Contrairement à la ++ approche, il utilise le CanBuildFrom mécanisme, et donc a le potentiel pour être plus efficace si la bibliothèque de code a été écrit pour profiter de cette:

    val m = collection.immutable.Map(1->"one",2->"Two")
val n = collection.mutable.Map(m.toSeq: _*)

    Cela fonctionne parce qu'un Map peut aussi être vu comme une séquence de Paires.

    • Pouvez-vous expliquer, ce que la syntaxe que vous utilisez dans la deuxième ligne, en passant le paramètre? Quel est le côlon faire?
    • : _* est un peu comme le type de nom, en disant que le compilateur exactement quel type de signe d'une expression donnée. Vous pouvez la voir ici que de dire "prendre cette séquence, et de le traiter comme un certain nombre de vararg params."
    • Il y a quelque chose de mal avec la collection de bibliothèques si c'est le plus propre 😉
    • Il pourrait être fait un peu plus courte avec des alias des importations, mais gardez à l'esprit que de sacrifier l'immuabilité est très non-idiomatique pour Scala, pas exactement le genre de truc que j'aimerais encourager en faisant paraître encore plus facile... par curiosité, comment pourriez-vous proposer de le faire plus proprement, si ce n'est par l'intermédiaire d'une copie?
    • C'est mon point de vue, je ne peux pas, mais une meilleure collections de la bibliothèque pourrait rendre cela possible, à mon humble avis.
    InformationsquelleAutor Kevin Wright
  2. 40
    val myImmutableMap = collection.immutable.Map(1->"one",2->"two")
val myMutableMap = collection.mutable.Map() ++ myImmutableMap
    • Savez-vous que le temps asymptotique de la complexité de ce qui est? Je sais que Clojure peut transformer n'importe quel de ses collections persistantes dans un "transitoire" (p. ex. une mutable un avec de façon linéaire de type de mutation des fonctions) et retour permanent un dans O(1) étapes. Ce regarde pour être O(n), bien que cela dépend des cours sur la façon intelligente de la mise en œuvre de ++ est.
    • Je suis sûr que ce est O(n). Dans la limite que vous tout changer, il doit être O(n), si vous pourriez essayer de différer la création de la nouvelle copie pour gagner du temps, ou vous double votre temps d'accès en lecture à des révisions à la place de la carte originale. Celui qui fonctionne le mieux dépend probablement sur votre cas d'utilisation.
    • Les cartes sont non-ordonnée. Ils apparaîtront dans n'importe quel ordre ils se sentent comme (avec une valeur de hachage de la carte, il est généralement de l'ordre de la clé de hachage). En particulier, immuable, les cartes ont des cas particuliers pour vraiment minuscules cartes qui sont différents de mutable cartes.
    • Les cartes ne sont pas commandés.
    InformationsquelleAutor Rex Kerr
  3. 4

    Comment au sujet de l'utilisation de collection.breakOut?

    import collection.{mutable, immutable, breakOut}
val myImmutableMap = immutable.Map(1->"one",2->"two")
val myMutableMap: mutable.Map[Int, String] = myImmutableMap.map(identity)(breakOut)
    • est cool, mais, fondamentalement, fait la même chose que mutable.Map#apply avec un peu plus passe-partout.
    InformationsquelleAutor ymnk
  4. 0

    Il y a une variante pour créer un vide mutable Map qui a des valeurs par défaut prises à partir de l'immuable Map. Vous pouvez stocker une valeur et remplacer la valeur par défaut à tout moment:

    scala> import collection.immutable.{Map => IMap}
//import collection.immutable.{Map=>IMap}

scala> import collection.mutable.HashMap
//import collection.mutable.HashMap

scala> val iMap = IMap(1 -> "one", 2 -> "two")
//iMap: scala.collection.immutable.Map[Int,java.lang.String] = Map((1,one), (2,two))

scala> val mMap = new HashMap[Int,String] {      
     | override def default(key: Int): String = iMap(key)
     | }
//mMap: scala.collection.mutable.HashMap[Int,String] = Map()

scala> mMap(1)
//res0: String = one

scala> mMap(2)
//res1: String = two

scala> mMap(3)
//java.util.NoSuchElementException: key not found: 3
// at scala.collection.MapLike$class.default(MapLike.scala:223)
// at scala.collection.immutable.Map$Map2.default(Map.scala:110)
// at scala.collection.MapLike$class.apply(MapLike.scala:134)
// at scala.collection.immutable.Map$Map2.apply(Map.scala:110)
// at $anon$1.default(<console>:9)
// at $anon$1.default(<console>:8)
// at scala.collection.MapLike$class.apply(MapLike.scala:134)....

scala> mMap(2) = "three"

scala> mMap(2)          
//res4: String = three

    Mise en garde (voir le commentaire par Rex Kerr): Vous ne serez pas en mesure de supprimer les éléments venant de l'immuable carte:

    scala> mMap.remove(1)
//res5: Option[String] = None

scala> mMap(1)
//res6: String = one
    • C'est utile dans certains cas, mais notez que vous ne parvenez pas à supprimer un élément de votre nouvelle carte, qui était présent dans votre carte par défaut; vous pouvez seulement de couvrir et découvrir les valeurs par défaut.
    • Droit, cette solution n'est que partielle.
    InformationsquelleAutor Alexander Azarov
  5. 0

    De départ Scala 2.13, via l'usine de constructeurs appliquée avec .pour(usine):

    Map(1 -> "a", 2 -> "b").to(collection.mutable.Map)
//collection.mutable.Map[Int,String] = HashMap(1 -> "a", 2 -> "b")
    InformationsquelleAutor Xavier Guihot