Come si fa a Scala mutabile aggiornamento della Mappa [mappa(tasto) = nuovovalore] sintassi di lavoro?

Sto lavorando attraverso Cay Horstmann alla Scala e per gli Impazienti libro in cui mi sono imbattuto in questo modo l’aggiornamento di un mutevole mappa.

scala> val scores = scala.collection.mutable.Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
scores: scala.collection.mutable.Map[String,Int] = Map(Bob -> 3, Alice -> 10, Cindy -> 8)

scala> scores("Alice") //retrieve the value of type Int
res2: Int = 10

scala> scores("Alice") = 5 //Update the Alice value to 5

scala> scores("Alice")
res4: Int = 5

Sembra scores("Alice") colpisce apply in MapLike.scala. Ma questo restituisce solo il valore, non qualcosa che può essere aggiornato.

Per curiosità, ho provato la stessa sintassi in un immutabile mappa e stato presentato il seguente errore,

scala> val immutableScores = Map("Alice" -> 10, "Bob" -> 3, "Cindy" -> 8)
immutableScores: scala.collection.immutable.Map[String,Int] = Map(Alice -> 10, Bob -> 3, Cindy -> 8)

scala> immutableScores("Alice") = 5
<console>:9: error: value update is not a member of scala.collection.immutable.Map[String,Int]
              immutableScores("Alice") = 5
          ^

Sulla base di che, sto assumendo che scores("Alice") = 5 è trasformato in scores update ("Alice", 5) ma non ho idea di come funziona, o come è ancora possibile.

Come funziona?

  • Credo che sia solo sintattica di zucchero. Non c’è qualche profonde lezione qui da quanto ho capito.
  • Come si può vedere, il update viene chiamato il metodo, non il apply metodo.
  • immutabile significa sola Lettura e mutevole significa Lettura/Scrittura in modo che il problema era sollevate
InformationsquelleAutor Dan Midwood | 2013-03-24



3 Replies
  1. 24

    Questo è un esempio di apply, update sintassi.

    Quando si chiama map("Something") questo chiamate map.apply("Something") che a sua volta chiama get.

    Quando si chiama map("Something") = "SomethingElse" questo chiamate map.update("Something", "SomethingElse") che a sua volta chiama put.

    Dare un’occhiata a questo per una spiegazione più ampia.

  2. 0

    Puoi provare questo: => aggiorna l’elenco di Mappa

    import java.util.concurrent.ConcurrentHashMap
    import scala.collection.JavaConverters._
    import scala.collection.concurrent
    
    val map: concurrent.Map[String, List[String]] = new ConcurrentHashMap[String, List[String]].asScala
    
    def updateMap(key: String, map: concurrent.Map[String, List[String]], value: String): Unit = {
    map.get(key) match {
    case Some(list: List[String]) => {
    val new_list = value :: list
    map.put(key, new_list)
    }
    case None => map += (key -> List(value))
    }
    }
  3. -1

    Il problema è che si sta tentando di aggiornare immutabile mappa. Ho avuto lo stesso messaggio di errore quando la mia mappa è stata dichiarata come

    var m = new java.util.HashMap[String, Int]

    Ma quando ho sostituito la definizione, da parte

    var m = new scala.collection.mutable.HashMap[String, Int]

    il m.update lavorato.

    • OP definisce chiaramente la mappa come mutevole.
    • hashMap è mutevole collezione

Lascia un commento