3

我正在尝试使用不可变映射在scala中实现一个简单的字数（这是故意的），我试图完成它的方式如下：

  1. 创建一个空的不可变映射
  2. 创建一个读取文件的扫描仪。

  3. 虽然scanner.hasNext() 为真：

    • 检查 Map 是否包含该单词，如果不包含该单词，则将计数初始化为零
    • 使用 key=word 和 value=count+1 创建一个新条目
    • 更新地图

  4. 在迭代结束时，地图将填充所有值。

我的代码如下：

val wordMap = Map.empty[String,Int]
val input = new java.util.scanner(new java.io.File("textfile.txt"))
while(input.hasNext()){
  val token = input.next()
  val currentCount = wordMap.getOrElse(token,0) + 1
  val wordMap = wordMap + (token,currentCount)
}

想法是 wordMap 将在迭代结束时拥有所有 wordCounts ......每当我尝试运行这个片段时，我都会得到以下异常

递归值 wordMap 需要类型。

有人可以指出为什么我会遇到这个异常，我能做些什么来补救它？

谢谢

4

2 回答 2

7 
val wordMap = wordMap + (token,currentCount)

这一行正在重新定义一个已经定义的变量。如果你想这样做，你需要定义wordMap，var然后使用

wordMap = wordMap + (token,currentCount)

虽然这个怎么样？：

io.Source.fromFile("textfile.txt")            // read from the file
  .getLines.flatMap{ line =>                  // for each line
     line.split("\\s+")                       // split the line into tokens
       .groupBy(identity).mapValues(_.size)   // count each token in the line
  }                                           // this produces an iterator of token counts
  .toStream                                   // make a Stream so we can groupBy
  .groupBy(_._1).mapValues(_.map(_._2).sum)   // combine all the per-line counts
  .toList

请注意，每行预聚合用于尝试减少所需的内存。一次计算整个文件可能太大了。

如果您的文件非常庞大，我建议您使用 Scala 的并行集合或 Hadoop（使用 Scrunch 或 Scoobi 等很酷的 Scala Hadoop 包装器之一）并行执行此操作（因为字数统计对于并行化来说很简单）。

编辑：详细说明：

好的，首先看一下flatMap的内部。我们取一个字符串，并用空格将其拆分：

val line = "a b c b"
val tokens = line.split("\\s+") // Array(a, b, c, a, b)

现在identity is a function that just returns its argument, so if wegroupBy(identity)`，我们将每个不同的单词类型映射到每个单词标记：

val grouped = tokens.groupBy(identity) // Map(c -> Array(c), a -> Array(a), b -> Array(b, b))

最后，我们要计算每种类型的令牌数量：

val counts = grouped.mapValues(_.size) // Map(c -> 1, a -> 1, b -> 2)

由于我们将其映射到文件中的所有行，因此我们最终得到了每一行的标记计数。

那么做flatMap什么呢？好吧，它在每一行上运行令牌计数函数，然后将所有结果合并到一个大集合中。

假设文件是​​：

a b c b
b c d d d
e f c

然后我们得到：

val countsByLine = 
  io.Source.fromFile("textfile.txt")            // read from the file
    .getLines.flatMap{ line =>                  // for each line
       line.split("\\s+")                       // split the line into tokens
         .groupBy(identity).mapValues(_.size)   // count each token in the line
    }                                           // this produces an iterator of token counts
println(countsByLine.toList) // List((c,1), (a,1), (b,2), (c,1), (d,3), (b,1), (c,1), (e,1), (f,1))

所以现在我们需要将每一行的计数组合成一大组计数。countsByLine变量是一个，Iterator所以它没有groupBy方法。相反，我们可以将其转换为 a Stream，这基本上是一个惰性列表。我们想要惰性是因为我们不想在开始之前将整个文件读入内存。然后这些groupBy组将所有相同的单词类型一起计数。

val groupedCounts = countsByLine.toStream.groupBy(_._1)
println(groupedCounts.mapValues(_.toList)) // Map(e -> List((e,1)), f -> List((f,1)), a -> List((a,1)), b -> List((b,2), (b,1)), c -> List((c,1), (c,1), (c,1)), d -> List((d,3)))

最后，我们可以通过从每个元组中获取第二项（计数）来总结每个单词类型的每一行的计数，然后求和：

val totalCounts = groupedCounts.mapValues(_.map(_._2).sum)
println(totalCounts.toList)
List((e,1), (f,1), (a,1), (b,3), (c,3), (d,3))

你有它。

于 2012-04-15T20:37:43.873 回答
3

你有几个错误：你定义wordMap了两次（val是声明一个值）。此外，Map它是不可变的，因此您必须将其声明为 avar或使用可变映射（我建议前者）。

试试这个：

var wordMap = Map.empty[String,Int] withDefaultValue 0
val input = new java.util.Scanner(new java.io.File("textfile.txt"))
while(input.hasNext()){
  val token = input.next()
  wordMap += token -> (wordMap(token) + 1)
}
于 2012-04-15T20:37:13.123 回答