/////////////////////////////////////
def numsFrom(n: Int): Stream[Int] = n #:: numsFrom(n + 1)
def testStream = {
val tenOrMore = numsFrom(10)
println(tenOrMore)
println(tenOrMore.tail)
println(tenOrMore.tail.tail)
println(tenOrMore.tail.tail.tail)
val squares = numsFrom(1).map { x => x * x }
println(squares)
println(squares.take(5).force)
println(squares take 5 mkString(", "))
val pom = Source.fromFile("pom.xml").getLines().toStream
println(pom)
pom.take(10).force.foreach { println }
}
/////////////////////////////////////
/*
output
Stream(10, ?)
Stream(11, ?)
Stream(12, ?)
Stream(13, ?)
Stream(1, ?)
Stream(1, 4, 9, 16, 25)
1, 4, 9, 16, 25
Stream(<?xml version="1.0"?>, ?)
<?xml version="1.0"?>
<project
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>cn.test</groupId>
<artifactId>test-parent</artifactId>
<version>0.0.1-SNAPSHOT</version>
</parent>
*/
原文链接 http://www.importnew.com/3587.html
对于一组值序列的处理，Scala提供了一些功能强大的抽象。函数式编程鼓励使用包含所有状态的声明式列表，而避免使用变量和可变状态。高阶函数，例如map，flatMap和filter可以很简洁地实现复杂的需求。
例如，假如你在编写一个搜索引擎，并且你的用户需要在一个包含10,0000个HTML文档的数据库里查找关于Scala的第10个文档。在函数式的语言里，你可能会声明一个包含所有文档的列表，然后分别查看每一个文档看看是否是关于Scala，最后获取第10份文档。可能和下面的代码看起来相似：
|
1 |
|
这里的问题在于，如果HTML的文档数量有10,000这么多的话，你首先需要一个一个地处理这10,000个文档，来看看它是否是关于Scala的，然后来构建这个过滤了的列表——这仅仅只是为了获取第10个文档。显然这种开销的扩展性不是很好！
一种解决方案是使用Scala的Stream结构，它和列表相似，只不过它会延迟计算下一个元素，仅当需要的时候才会去计算。使用Stream只会进行必要的处理来查找第10份文档 – 而不是对所有的10,000份文档同时进行计算。
要查看Stream的详细介绍，你可以参考《Scala By Example》里的“Computing with Streams”。
那么，Stream究竟是如何起作用的呢？所谓的延迟处理又是怎么定义的呢？深入了解Stream的实现细节，可以发现Scala语言以及构建类库所采纳的一些很好的理念。
构造一个Stream需要使用Stream.cons和Stream.empty：
|
1 |
|
乍一看，cons似乎是Stream对象的一个方法。但是，事实上它是Stream对象的一个内部对象。
Stream.cons是一个对象，而不是Stream对象的一个方法
查看Scala类库里的Stream.scala，你会发现下面的结果：
|
1 2 3 4 5 6 |
|
这种嵌套对象的方式在Java里也是可行的。不过，Scala里使用apply()方法（这个我们后面会讨论）意味着嵌套类的cons的方法调用看起来是Stream对象上的方法调用。
语法糖(Syntactic sugar)和apply()方法
回想一下，Scala对象可能会这样定义apply()方法：
|
1 2 3 4 |
|
这就意味着，你可以通过下面的语法来调用List对象创建一个包含1，2和3的列表：
|
1 |
|
或者使用Scala的语法糖：
|
1 |
|
对于我而言，apply()的语法糖和嵌套的单例对象的组合很好的诠释了Scala语言的特点。一个方法调用实际上是对一个内部对象的方法调用，不过语法上却没有区别。终端用户不需要了解你是否在操作类库中的一个类的嵌套内部对象；因为它和标准的函数调用没有区别。
不过，Stream的延迟处理是怎么实现的呢？
Call by name 求值
在看一看Stream.cons的apply方法的签名：
|
1 |
|
注意=>操作符；它表示一个call-by-name求值。这是参数延迟求值的一种形式；tail参数只会在需要使用的时候才会被求值。
这样，Scala就可以允许你毫无顾忌地创建一个开销很大的列表；运行时环境会一个一个地对Stream中的元素进行求值，知道指定的条件达到——并且后面的元素不会被求值。
想了解更多关于Scala的Stream的话，你可以参考这篇文章，它介绍了如何使用Scala解决Euler项目里的问题。
英文原文: Looking at Streams in Scala，翻译：ImportNew - 朱伟杰
本文地址：http://www.importnew.com/3587.html