play scala 1 用stream表示全体自然数

1.在创建一个List的时候,tail是立即被evaluated,如果把构造函数中的tail改成call by name的参数,而可以在用到tail的时候才计算tail。stream的实现就是用了这个思想

Steam的简单实现

  def cons[T](hd: T, tl: => Stream[T]) = new Stream[T] {
    def isEmpty = false
    def head = hd
    def tail = tl
  }
  val empty = new Stream[Nothing] {
    def isEmpty = true
    def head = throw new NoSuchElementException("empty.head")
    def tail = throw new NoSuchElementException("empty.tail")
  }


2. 用lazy value改进Stream

上面的实现中, tail是个函数,虽然 tail在用到的时候才会被计算,但是每次用到都会计算一次。我们不能复用上次计算的结果。

来看一个例子

package week7

object  testStream extends App {
  def expr = {
    val x = { print("x"); 1}
    lazy val y = { print("y"); 2}
    def z = { print("z"); 3}
    z + y + x + z + y + x
  }
  expr   //xzyz
}

改进 stream的实现

def tail = tl


3. 用Stream表示自然数集合

递归表达: from(n) = {n}  U  from(n+1) 

def from(n: Int): Stream[Int] = n #:: from(n+1)

自然数中所有4的倍数

    val nats = from(0)                            //> nats  : Stream[Int] = Stream(0, ?)
    val mt4 = nats map (_*4)                      //> mt4  : scala.collection.immutable.Stream[Int] = Stream(0, ?)
    (mt4 take 100) toList                         //> res0: List[Int] = List(0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 
                                                  //| 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112, 116, 120, 12
                                                  //| 4, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184
                                                  //| , 188, 192, 196, 200, 204, 208, 212, 216, 220, 224, 228, 232, 236, 240, 244,
                                                  //|  248, 252, 256, 260, 264, 268, 272, 276, 280, 284, 288, 292, 296, 300, 304, 
                                                  //| 308, 312, 316, 320, 324, 328, 332, 336, 340, 344, 348, 352, 356, 360, 364, 3
                                                  //| 68, 372, 376, 380, 384, 388, 392, 396)


4. Sieve of Eratosthenes 算法的scala 表达

    def sieve(s: Stream[Int]): Stream[Int] = {
      s.head #:: sieve(s.tail filter (_ % s.head != 0))
    }                                             //> sieve: (s: Stream[Int])Stream[Int]
    
    val prims = sieve(from(2))                    //> prims  : Stream[Int] = Stream(2, ?)
    
    prims take 100 toList                         //> res1: List[Int] = List(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 4
                                                  //| 7, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131
                                                  //| , 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211,
                                                  //|  223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 
                                                  //| 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 3
                                                  //| 97, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 48
                                                  //| 7, 491, 499, 503, 509, 521, 523, 541)

5.最后来解释一下 #:: 操作符, 这个方法并不是在 Stream类中定义的,而是通过隐式转化调了 object  Stream 的 StreamWrapper的#::方法,这个方法又调了Stream.cons方法。所以

a #:: mystream  == Stream.cons(a ,mysteam)


6.Stream带来的一个不好的影响是:看似无限循环的代码,其实就执行了一点。你如果对lazy value理解的不深,很难推测一个语句到底执行了多少次。

有一个原则是: lazy value是会传递的,只到遇到第一个strict value为止

你可能感兴趣的:(scala,Stream,全体自然数)