10

我有一个java.lang.Iterable懒惰地计算它的值。我正在从 Scala 访问它。是否有只返回不同值的核心 API 方式？例如，成像有一个过滤器方法，它还提供了迄今为止返回的所有结果：

val myLazyDistinctIterable = iterable.filter((previousReturnedItems, newItem) => previousReturnedItems.contains(newItem))

我想这不是一个非常普遍的情况，因为它涉及存储以前返回的项目，这可能就是它不在核心 API 中的原因。

我知道List.distinctand Sets 但我想要一些在被问到之前不会计算其元素的东西。

4

5 回答 5

12

您可以使用上的distinct方法Stream。例如，如果你有这个Iterable：

val it = new java.lang.Iterable[Int] {
  def iterator = new java.util.Iterator[Int] {
    var i = 0
    var first = true

    def hasNext = true
    def next =
      if (first) { first = false; i } else { first = true; i += 1; i - 1 }
    def remove() { throw new UnsupportedOperationException("Can't remove.") }
  }
}

你可以写：

scala> import scala.collection.JavaConverters._
import scala.collection.JavaConverters._

scala> val s = it.asScala.toStream
s: scala.collection.immutable.Stream[Int] = Stream(0, ?)

scala> s.take(10).toList
res0: List[Int] = List(0, 0, 1, 1, 2, 2, 3, 3, 4, 4)

scala> val s = it.asScala.toStream.distinct
s: scala.collection.immutable.Stream[Int] = Stream(0, ?)

scala> s.take(10).toList
res1: List[Int] = List(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

我们可以说一切都是适当的惰性，因为流是无限的。

于 2013-04-24T16:31:04.753 回答
8

更新仔细阅读问题是好的。这个解决方案没有懒惰。对不起。

toSet会做你想做的事：

  1. 将迭代的元素存储在集合中（不是您想要的，但需要）
  2. 删除/替换重复项

例子

val it = Seq(1,2,3,4,2,4): Iterable[Int]
it.toSet
// Set(1,2,3,4)

如果您觉得花哨，可以将其转换回可迭代的：

it.toSet.toIterable

或者，拉皮条Iterable：

implicit class UniquableIterable[T](t: Iterable[T]) {
  def unique = t.toSet.toIterable
}

然后打电话

it.unique
于 2013-04-24T16:28:38.997 回答
1

这是将.disctinct方法添加到Iterator.

implicit class IteratorWrapper[T](it: Iterator[T]) {
    def distinct = new Iterator[T] {
        var seen = Set.empty[T]
        var ahead = Option.empty[T]

        def searchAhead {
            while (ahead.isEmpty && it.hasNext) {
                val v = it.next
                if (!seen(v)) {
                    seen += v
                    ahead = Some(v)
                }
            }
        }

        def hasNext = {
            searchAhead
            ahead.nonEmpty
        }

        def next = {
            searchAhead
            val result = ahead.get
            ahead = None
            result
        }
    }
}

请注意，与迭代器通常一样，原始迭代器在调用后无效.distinct。

于 2015-02-06T19:49:36.643 回答
1

扩展我上面的评论，但我现在无法测试它：

def unique[A](it: Iterator[A]): Iterator[A] = {
  val seen = mutable.Set[A]()
  it.filter { a =>
    if (seen(a))
      false
    else {
      seen += a
      true
    }
  }
}

至少你明白了。然后，您会将其应用于从可迭代对象中获得的迭代器，而不是获得不必要的Stream.

于 2013-04-24T20:37:29.103 回答
0

这应该可以完成工作（但我讨厌）：

class UniqueIterable[T](i: Iterable[T]) extends Iterable[T] {
  import scala.collection.mutable.Set
  def iterator = new Iterator[T] {
    val it = i.iterator
    var nextE: Option[T] = None
    val seen: Set[T] = Set.empty
    def hasNext = {
      popNext()
      nextE.isDefined
    }
    def next = {
      popNext()
      val res = nextE.get
      nextE = None
      res
    }

    @tailrec
    private def popNext() {
      if (nextE.isEmpty && it.hasNext) {
        val n = it.next
        if (seen contains n) popNext()
        else {
          seen += n
          nextE = Some(n)
        }
      }
    }
  }
}
于 2013-04-24T16:43:24.963 回答