0

我正在对集合进行并行化以计算列表中相同项目值的数量。在这种情况下，列表是 uniqueSetOfLinks ：

for (iListVal <- uniqueSetOfLinks.par) {
  try {
      val num : Int = listOfLinks.count(_.equalsIgnoreCase(iListVal))
      linkTotals + iListVal -> num
  }
  catch {
  case e : Exception => {
   e.printStackTrace() 
  }
  }
}

linkTotals 是一个不可变的 Map。要获得对链接总数的引用，我是否需要更新 linkTotals 以使其不可变？

然后我可以做类似的事情：

linkTotals.put(iListVal, num)
4

3 回答 3

3

您无法更新不可变集合，您所能做的就是将不可变集合与添加元素结合起来以获得新的不可变集合，如下所示：

val newLinkTotals = linkTotals + (iListVal -> num)

在收集的情况下，您可以创建新的对集合，然后将所有对添加到地图中：

val optPairs =
  for (iListVal <- uniqueSetOfLinks.par)
    yield
      try {
        val num : Int = listOfLinks.count(_.equalsIgnoreCase(iListVal))
        Some(iListVal -> num)
      }
      catch {
        case e : Exception =>  e.printStackTrace()
        None
      }


val newLinkTotals = linkTotals ++ optPairs.flatten // for non-empty initial map
val map = optPairs.flatten.toMap // in case there is no initial map

请注意，您使用的是并行集合 ( .par)，因此不应使用可变状态，例如linkTotals += iListVal -> num.

于 2013-08-08T12:32:03.863 回答
1

@senia 答案的可能变体（去掉了显式flatten）：

val optPairs =
  (for {
    iListVal <- uniqueSetOfLinks.par
    count <- {
      try
        Some(listOfLinks.count(_.equalsIgnoreCase(iListVal)))
      catch {
        case e: Exception =>
          e.printStackTrace()
          None
      }
    }
  } yield iListVal -> count) toMap
于 2013-08-08T16:27:05.453 回答
0

我认为您需要某种形式的 MapReduce 才能进行并行项目数估计。

在您的问题中，您已经拥有所有唯一链接。map 的部分中间结果只是一对。而“reduce”就是toMap。因此，您可以简单地将链接映射到配对 (link-> count)，然后最后构造一个映射：

def count(iListVal:String) = listOfLinks.count(_.equalsIgnoreCase(iListVal))
val listOfPairs = uniqueSetOfLinks.par.map(iListVal => Try( (iListVal, count(iListVal)) ))

（“map”操作是par-map）

然后删除异常：

val clearListOfPairs = listOfPairs.flatMap(_.toOption)

然后简单地将其转换为地图（“减少”）：

val linkTotals = clearListOfPairs.toMap

（如果需要检查异常，请使用 Try.failure）

于 2013-08-09T06:31:14.613 回答