Scala 中流的用例

Question

Scala 中有一个 Stream 类，它非常类似于迭代器。主题 Scala 中迭代器和流之间的区别？ 提供了一些见解两者之间的相同点和不同点。

了解如何使用流非常简单，但我没有很多常见用例，我会使用流而不是其他工件。

我现在的想法是：

• 如果你需要使用无限级数。但这对我来说似乎不是一个常见的用例，所以它不符合我的标准。 （如果它很常见并且我只是有一个盲点，请纠正我）
• 如果您有一系列数据，其中每个元素都需要计算，但您可能想重复使用多次。这是很弱的，因为我可以将它加载到一个列表中，这在概念上对于大部分开发人员来说更容易遵循。
• 也许有大量数据或计算成本较高的系列，并且您需要的项目很可能不需要访问所有元素。但在这种情况下，迭代器将是一个很好的匹配，除非您需要进行多次搜索，在这种情况下，您也可以使用列表，即使它的效率稍低。
• 有一系列复杂的数据需要重用。这里可以再次使用列表。尽管在这种情况下，两种情况都同样难以使用，并且 Stream 会更适合，因为并非所有元素都需要加载。但同样不常见……是吗？

那么我是否错过了任何重大用途？或者这在很大程度上是开发人员的偏好？

谢谢

Answer 1

Stream 和 Iterator 之间的主要区别在于后者是可变的且“一次性”，可以这么说，而前者则不然。 Iterator 比 Stream 具有更好的内存占用，但事实上它是可变的，这可能会带来不便。

以这个经典的素数生成器为例：

def primeStream(s: Stream[Int]): Stream[Int] =
  Stream.cons(s.head, primeStream(s.tail filter { _ % s.head != 0 }))
val primes = primeStream(Stream.from(2))

它也可以很容易地用 Iterator 编写，但 Iterator 不会保留到目前为止计算出的素数。

因此，Stream 的一个重要方面是您可以将其传递给其他函数，而无需先复制它，也不必一次又一次地生成它。

至于昂贵的计算/无限列表，这些事情也可以使用迭代器来完成。无限列表实际上非常有用——您只是不知道它，因为您没有它，所以您已经看到了比处理强制有限大小严格必需的算法更复杂的算法。

Answer 2

除了丹尼尔的回答之外，请记住 Stream 对于短路评估很有用。例如，假设我有一大堆函数，它们接受 String 并返回 Option[String]，并且我想继续执行它们，直到其中一个起作用：

val stringOps = List(
  (s:String) => if (s.length>10) Some(s.length.toString) else None ,
  (s:String) => if (s.length==0) Some("empty") else None ,
  (s:String) => if (s.indexOf(" ")>=0) Some(s.trim) else None
);

嗯，我当然不想执行整个列表，并且List上没有任何方便的方法说：“将它们视为函数并执行它们，直到其中之一它们返回的不是 None”。该怎么办？也许是这样的：

def transform(input: String, ops: List[String=>Option[String]]) = {
  ops.toStream.map( _(input) ).find(_ isDefined).getOrElse(None)
}

这需要一个列表并将其视为 Stream （实际上并不评估任何内容），然后定义一个新的 Stream，它是应用函数的结果（但这还没有评估任何内容），然后搜索定义的第一个 - 在这里，它神奇地回顾并意识到它必须应用地图，并从原始列表中获取正确的数据 - - 然后使用 getOrElse 将其从 Option[Option[String]] 解包到 Option[String]。

这是一个例子：

scala> transform("This is a really long string",stringOps)
res0: Option[String] = Some(28)

scala> transform("",stringOps)
res1: Option[String] = Some(empty)

scala> transform("  hi ",stringOps)
res2: Option[String] = Some(hi)

scala> transform("no-match",stringOps)
res3: Option[String] = None

但这有效吗？如果我们将 println 放入我们的函数中，以便我们可以判断它们是否被调用，我们会得到

val stringOps = List(
  (s:String) => {println("1"); if (s.length>10) Some(s.length.toString) else None },
  (s:String) => {println("2"); if (s.length==0) Some("empty") else None },
  (s:String) => {println("3"); if (s.indexOf(" ")>=0) Some(s.trim) else None }
);
// (transform is the same)

scala> transform("This is a really long string",stringOps)
1
res0: Option[String] = Some(28)

scala> transform("no-match",stringOps)                    
1
2
3
res1: Option[String] = None

（这是 Scala 2.8 的情况；不幸的是，2.7 的实现有时会超出 1。请注意，您随着失败的增加，确实会积累一长串None，但与此处的真实计算相比，这可能是便宜的。）

Answer 3

我可以想象，如果您实时轮询某些设备，则 Stream 会更方便。

想象一下 GPS 跟踪器，如果您询问，它会返回实际位置。您无法预先计算 5 分钟后您将到达的位置。您可能只使用它几分钟来在 OpenStreetMap 中实现一条路径，或者您可能会使用它在沙漠或雨林中进行六个月以上的探险。

或者数字温度计或其他类型的传感器，只要硬件处于活动状态并打开，就会重复返回新数据 - 日志文件过滤器可能是另一个例子。

Answer 4

Stream 之于 Iterator 就像 immutable.List 之于 mutable.List 一样。支持不变性可以防止一类错误，有时会以性能为代价。

scalac 本身也无法避免这些问题：http://article. gmane.org/gmane.comp.lang.scala.internals/2831

正如 Daniel 指出的，偏向惰性而不是严格可以简化算法并使其更容易编写。