Scala коллекции, один ключ, несколько значений

У меня есть список родительских ключей, каждый из которых может иметь ноль или более связанных значений. Я не уверен, какую коллекцию использовать.

я использую Map[Int,List[String]]

Я объявляю карту как

var nodes = new HashMap[Int, List[String]]

Тогда у меня есть два метода для обработки добавления новых элементов. Первое - добавить новые ключи. addNode а второе это добавить новые значения addValue, Изначально ключ не будет иметь никаких значений, связанных с ним. Позже, во время выполнения, новые значения будут связаны.

def addNode(key: Int) = nodes += (key -> "")

def addValue(key: Int, value: String) = ???

Я не уверен, как реализовать addValues

Обновить:

В ответ на ответ @oxbow-lakes Это ошибка, которую я получаю. Обратите внимание, что ключи не обязательно должны иметь связанные с ними значения.

scala> var nodes = Map.empty[Int, List[String]]
nodes: scala.collection.immutable.Map[Int,List[String]] = Map()

scala> nodes += (1->null)

scala> nodes += (1 -> ("one" :: (nodes get 1 getOrElse Nil)))
java.lang.NullPointerException
    at .<init>(<console>:9)
    at .<clinit>(<console>)
    at .<init>(<console>:11)
    at .<clinit>(<console>)
    at $print(<console>)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at scala.tools.nsc.interpreter.IMain$ReadEvalPrint.call(IMain.scala:704)
    at scala.tools.nsc.interpreter.IMain$Request$$anonfun$14.apply(IMain.scala:920)
    at scala.tools.nsc.interpreter.Line$$anonfun$1.apply$mcV$sp(Line.scala:43)
    at scala.tools.nsc.io.package$$anon$2.run(package.scala:25)
    at java.lang.Thread.run(Thread.java:680)

Обновление 2:

Проблема с кодом выше - строка nodes += (1->null) ключ должен быть связан с Nil вместо. Ниже приведен рабочий код.

scala> var nodes = Map.empty[Int, List[String]]
nodes: scala.collection.immutable.Map[Int,List[String]] = Map()

scala> nodes += (1->Nil)

scala> nodes += (1 -> ("one" :: (nodes get 1 getOrElse Nil)))

scala> nodes
res27: scala.collection.immutable.Map[Int,List[String]] = Map(1 -> List(one))
Источник

3 ответа

Решение

Использование MultiMap

Вы, возможно, хотите использовать MultiMap, который является изменчивой коллекцией, изоморфной Map[K, Set[V]], Используйте следующим образом:

import collection.mutable
val mm = new mutable.HashMap[Int, mutable.Set[String]] with mutable.MultiMap[Int, String]

Затем вы добавляете свои узлы:

mm addBinding (key, value)

Без MultiMap

Альтернатива - придерживаться неизменных значений. Предполагая, что вы хотите избежать использования линз (см. Скаляр), вы можете добавить узлы следующим образом:

nodes += (key -> (value :: (nodes get key getOrElse Nil)))

Вот это работает (в ответ на ваш комментарий):

scala> var nodes = Map.empty[Int, List[String]]
nodes: scala.collection.immutable.Map[Int,List[String]] = Map()

scala> def addNode(key: Int, value: String) =
     | nodes += (key -> (value :: (nodes get key getOrElse Nil)))
addNode: (key: Int, value: String)Unit

scala> addNode(1, "Hi")

scala> addNode(1, "Bye")

scala> nodes
res2: scala.collection.immutable.Map[Int,List[String]] = Map(1 -> List(Bye, Hi))

Использование Скалаза

Используя библиотеку scalaz, вы можете понять, что это просто Empty шаблон:

nodes += (key -> (value :: ~(nodes get key)))

Или вы можете воспользоваться тем, что Map это моноид:

nodes = nodes |+| Map(key -> List(value))
Источник

В дополнение к ответу @oxbow_lakes, вот идея, как вы могли бы использовать addMap метод, который правильно добавляет две карты вместе (т.е. объединяет списки для соответствующих ключей, добавляет новые списки для новых ключей):

class EnhancedListMap(self: Map[Int,List[String]]) {
  def addMap(other: Map[Int,List[String]]) =
    (this.ungroup ++ enhanceListMap(other).ungroup)
      .groupBy(_._1)
      .mapValues(_.map(_._2))

  def ungroup() =
    self.toList.flatMap{ case (k,vs) => vs.map(k -> _) }
}

implicit def enhanceListMap(self: Map[Int,List[String]]) = new EnhancedListMap(self)

И вы бы использовали это так:

val a = Map(1 -> List("a","b"), 2 -> List("c","d"))
val b = Map(2 -> List("e","f"), 3 -> List("g","h"))
a addMap b
//Map(3 -> List(g, h), 1 -> List(a, b), 2 -> List(c, d, e, f))

Вы можете включить addNode, addValue, а также addValues так же (чтобы EnhancedListMap выше):

  def addNode(key: Int) =
    if(self contains key) self else self + (key -> Nil)

  def addValue(key: Int, value: String) =
    self + (key -> (value :: (self get key getOrElse Nil)))

  def addValues(key: Int, values: List[String]) =
    self + (key -> (values ::: (self get key getOrElse Nil)))

А затем использовать их вместе:

var nodes = Map.empty[Int, List[String]]             
// Map()
nodes = nodes.addNode(1)                             
// Map(1 -> List())
nodes = nodes.addValue(1,"a")                        
// Map(1 -> List(a))
nodes = nodes.addValue(2,"b")                        
// Map(1 -> List(a), 2 -> List(b))
nodes = nodes.addValues(2,List("c","d"))             
// Map(1 -> List(a), 2 -> List(c, d, b))
nodes = nodes.addValues(3,List("e","f"))             
// Map(1 -> List(a), 2 -> List(c, d, b), 3 -> List(e, f))
nodes = nodes.addMap(Map(3 -> List("g","h"), 4-> List("i","j")))
// Map(1 -> List(a), 2 -> List(c, d, b), 3 -> List(e, f, g, h), 4 -> List(i, j))
Источник

Мне очень нравится getOrElseUpdate метод, предоставляемый изменяемыми картами:

import scala.collection.mutable._

private val nodes = new HashMap[Int, Buffer[String]]

def addNode(key: Int): Unit =
  nodes.getOrElseUpdate(key, new ArrayBuffer)

def addValue(key: Int, value: String): Unit  =
  nodes.getOrElseUpdate(key, new ArrayBuffer) += value
Источник
Другие вопросы по тегам