我有一个元素迭代器，我想使用它们直到下一个元素满足条件，例如：
val it = List(1,1,1,1,2,2,2).iterator
val res1 = it.takeWhile( _ == 1).toList
val res2 = it.takeWhile(_ == 2).toList
res1 给出预期的List(1,1,1,1) 但res2 返回List(2,2)，因为迭代器必须检查位置 4 中的元素。
我知道列表将被排序，因此没有必要像 partition 那样遍历整个列表。我喜欢在条件不满足时尽快完成。有没有什么聪明的方法可以用迭代器做到这一点？我不能对迭代器执行toList，因为它来自一个非常大的文件。
【问题讨论】：
我找到的最简单的解决方案：
val it = List(1,1,1,1,2,2,2).iterator
val (r1, it2) = it.span( _ == 1)
println(s"group taken is: ${r1.toList}\n rest is: ${it2.toList}")
输出：
group taken is: List(1, 1, 1, 1)
rest is: List(2, 2, 2)
非常短，但您必须进一步使用新的迭代器。
对于任何不可变集合，它都是类似的：
【讨论】：
对于我的其他答案（我将其分开，因为它们基本上不相关），我认为您可以在 Iterator 上实现 groupWhen，如下所示：
def groupWhen[A](itr: Iterator[A])(p: (A, A) => Boolean): Iterator[List[A]] = {
@annotation.tailrec
def groupWhen0(acc: Iterator[List[A]], itr: Iterator[A])(p: (A, A) => Boolean): Iterator[List[A]] = {
val (dup1, dup2) = itr.duplicate
val pref = ((dup1.sliding(2) takeWhile { case Seq(a1, a2) => p(a1, a2) }).zipWithIndex collect {
case (seq, 0) => seq
case (Seq(_, a), _) => Seq(a)
}).flatten.toList
val newAcc = if (pref.isEmpty) acc else acc ++ Iterator(pref)
if (dup2.nonEmpty)
groupWhen0(newAcc, dup2 drop (pref.length max 1))(p)
else newAcc
}
groupWhen0(Iterator.empty, itr)(p)
}
当我在一个例子上运行它时：
println( groupWhen(List(1,1,1,1,3,4,3,2,2,2).iterator)(_ == _).toList )
我收到List(List(1, 1, 1, 1), List(2, 2, 2))
【讨论】：
我也有类似的需求，但是@oxbow_lakes 的solution 没有考虑到列表只有一个元素的情况，或者即使列表包含不重复的元素。此外，该解决方案不适合无限迭代器（它希望在给出结果之前“查看”所有元素）。
我需要的是能够对匹配谓词的顺序元素进行分组，但也包括单个元素（如果我不需要它们，我总是可以将它们过滤掉）。我需要持续交付这些组，而不必等待原始迭代器完全消耗完后再生成。
我想出了以下适合我需要的方法，并认为我应该分享：
implicit class IteratorEx[+A](itr: Iterator[A]) {
def groupWhen(p: (A, A) => Boolean): Iterator[List[A]] = new AbstractIterator[List[A]] {
val (it1, it2) = itr.duplicate
val ritr = new RewindableIterator(it1, 1)
override def hasNext = it2.hasNext
override def next() = {
val count = (ritr.rewind().sliding(2) takeWhile {
case Seq(a1, a2) => p(a1, a2)
case _ => false
}).length
(it2 take (count + 1)).toList
}
}
}
上面使用了一些辅助类：
abstract class AbstractIterator[A] extends Iterator[A]
/**
* Wraps a given iterator to add the ability to remember the last 'remember' values
* From any position the iterator can be rewound (can go back) at most 'remember' values,
* such that when calling 'next()' the memoized values will be provided as if they have not
* been iterated over before.
*/
class RewindableIterator[A](it: Iterator[A], remember: Int) extends Iterator[A] {
private var memory = List.empty[A]
private var memoryIndex = 0
override def next() = {
if (memoryIndex < memory.length) {
val next = memory(memoryIndex)
memoryIndex += 1
next
} else {
val next = it.next()
memory = memory :+ next
if (memory.length > remember)
memory = memory drop 1
memoryIndex = memory.length
next
}
}
def canRewind(n: Int) = memoryIndex - n >= 0
def rewind(n: Int) = {
require(memoryIndex - n >= 0, "Attempted to rewind past 'remember' limit")
memoryIndex -= n
this
}
def rewind() = {
memoryIndex = 0
this
}
override def hasNext = it.hasNext
}
使用示例：
List(1,2,2,3,3,3,4,5,5).iterator.groupWhen(_ == _).toList
给：List(List(1), List(2, 2), List(3, 3, 3), List(4), List(5, 5))
如果要过滤掉单个元素，只需在groupWhen 之后应用filter 或withFilter
Stream.continually(Random.nextInt(100)).iterator
.groupWhen(_ + _ == 100).withFilter(_.length > 1).take(3).toList
给：List(List(34, 66), List(87, 13), List(97, 3))
【讨论】：
您可以在Iterator 上使用方法toStream。
Stream 是 List 的惰性等效项。
从toStream 的implementation 可以看出，它创建了一个Stream，而不遍历整个Iterator。
Stream 将所有元素保存在内存中。您应该在某些本地范围内本地化指向Stream 的链接的使用，以防止内存泄漏。
对于Stream，您应该像这样使用span：
val (res1, rest1) = stream.span(_ == 1)
val (res2, rest2) = rest1.span(_ == 2)
【讨论】：
Stream 仅在存在指向第一个元素的链接时才保留元素。
Iterator 相同的行为，你可以使用Stream 的span 方法，但最好使用Iterator，正如@om-nom-nom 提到的那样。
我在这里猜测了一下，但是通过语句“直到在下一个元素中满足条件”，听起来您可能想查看@987654322 上的groupWhen 方法@ in scalaz
scala> import scalaz.syntax.std.list._
import scalaz.syntax.std.list._
scala> List(1,1,1,1,2,2,2) groupWhen (_ == _)
res1: List[List[Int]] = List(List(1, 1, 1, 1), List(2, 2, 2))
基本上，这会在元素与其后继元素之间满足条件（(A, A) => Boolean）时将输入序列“分块”。在上面的例子中，条件是相等，因此，只要一个元素与其后继元素相等，它们就会在同一个块中。
【讨论】：
EphemeralStream 的类。它没有groupWhen，但你可以很容易地写一个，因为它是一个monad。我不保证它不会溢出堆栈！
iterator.duplicate 功能将 groupBy 添加到迭代器。