Question

我正在编写一个小程序，它将一个非常大的文件转换成多个较小的文件，每个文件将包含100行。

我正在迭代一次迭代：

  while (lines.hasNext) {
      val line = lines.next()
  }

我想介绍一个计数器，当它达到一定值时，重置计数器然后继续。在java中我会做类似的事情：

int counter = 0;
      while (lines.hasNext) {
          val line = lines.next()
if(counter == 100){
 counter = 0;
}
++counter
      }

scala或替代方法中是否有类似内容？

Answer 1

传统上在scala中使用.zipWithIndex

scala> List("foo","bar")
res0: List[java.lang.String] = List(foo, bar)

scala> for((x,i) <- res0.zipWithIndex) println(i + " : " +x)
0 : foo
1 : bar

（这也适用于你的行，就像它们在Iterator中一样，例如有hasNext和next()方法，或者其他一些scala集合）

但是如果你需要一个复杂的逻辑，比如重置计数器，你可以用与java中相同的方式编写它：

var counter = 0
while (lines.hasNext) {
  val line = lines.next()
  if(counter % 100 == 0) {
    // now write to another file
  }
}

也许你可以告诉我们你为什么要重置计数器，所以我们可以说如何做得更好？

修改根据您的更新，最好使用分组方法，如@ pr1001建议：

lines.grouped(100).foreach(l => l.foreach(/* write line to file*/))

Answer 2

如果您的重置计数器表示原始列表中存在重复的数据组，您可能需要使用grouped方法：

scala> val l = List("one", "two", "three", "four")
l: List[java.lang.String] = List(one, two, three, four)

scala> l.grouped(2).toList
res0: List[List[java.lang.String]] = List(List(one, two), List(three, four))

更新：由于您正在从文件中读取文件，因此您应该可以非常有效地迭代文件：

val bigFile = io.Source.fromFile("/tmp/verybigfile")
val groupedLines = bigFile.getLines.grouped(2).zipWithIndex
groupedLines.foreach(group => {
  val (lines, index) = group
  val p = new java.io.PrintWriter("/tmp/" + index)
  lines.foreach(p.println)
  p.close()
})

当然，这也可以写成为理解......

在将每组行写入其自己的文件之前，您可以通过将groupedLines转换为具有.par的并行集合来获得更好的性能。

Answer 3

这样可行：

lines grouped 100 flatMap (_.zipWithIndex) foreach {
  case (line, count) => //whatever
}

Answer 4

您可以使用zipWithIndex以及一些转换。

scala> List(10, 20, 30, 40, 50).zipWithIndex.map(p => (p._1, p._2 % 3))
res0: List[(Int, Int)] = List((10,0), (20,1), (30,2), (40,0), (50,1))

将计数器引入scala中的循环

4 个答案: