Scala 中的递归流和集合

递归形式有它们自己的定义，就像我们在文件夹中有子文件夹一样，文件夹中还可以有子文件夹。调用自身的递归方法也是一种递归形式。类似的形式可用于创建递归流。

示例 1：创建惰性列表

// Scala program for resursive stream
// creating object 
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // second con can be recursive
        lazy val geek = Stream.cons(1, Stream.cons(5, Stream.empty))
          
        println (geek)
          
        (geek take 4) foreach {
            x => println(x)
          
        } 
    } 
} 

输出 ：

Stream(1, ?)
1
5

在上面的代码中，第二个 con 可以是递归的。

示例 2：通过对方法进行递归调用来创建惰性列表

// Scala program for resursive stream
  
// creating object 
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // con can be recursive
        def geek(n: Int): Stream[Int] = Stream.cons(n, geek(n+1))
          
        // Creating lazy val
        lazy val q = geek(5)
          
        println(q) 
    } 
} 

输出 ：

Stream(5, ?)

示例 3：通过以简洁明了的方式对方法进行递归调用来创建惰性列表

// Scala program for resursive stream
  
// creating object 
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // recursive stream
        def geek(n: Int):Stream[Int] = n #:: geek(n+1)
          
        // Lazy value
        lazy val q = geek(5)
          
        println(q)
  
    } 
} 

输出 ：

Stream(5, ?)

流集合

scala 中的流集合非常重要，因为它不需要显式覆盖。声明式的事情可以使用诸如 map、filter 和 flatMap 之类的功能组合器来执行。流是惰性丢失的集合。

示例 4：

// Scala program for stream collection
  
// creating object 
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // creating Stream
        def geek(n: Int):Stream[Int] = n #:: geek(n+1)
          
        lazy val g = geek(0)
          
        println (g)
        println (g.take(10).mkString(" ; "))
    } 
} 

输出 ：

Stream(0, ?)
0 ; 1 ; 2 ; 3 ; 4 ; 5 ; 6 ; 7 ; 8 ; 9)

示例 5：使用过滤器

// Scala program for filter list
  
// creating object 
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // Creating list
        val geek = List(1, 2, 3, 4)
          
        // Using filter
        val abc = geek filter { x => x > 2 }
        println(abc)
    } 
} 

输出 ：

List(3, 4)

filter 在列表 geek 上调用。它将函数作为参数并返回一个布尔值，它是一个函数谓词。每个元素都通过函数运行，并且在函数返回 false 的地方过滤掉元素。它会产生一个新列表，并且原始的“极客”列表保持不变。

示例 6：以非常简洁的方式使用过滤器

// Scala program for collection
  
// creating object 
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // Creating list
        val geek = List(1, 2, 3, 4)
          
        // Filter list
        val abc = geek filter { _ > 2 }
        println(abc)
  
    } 
} 

输出 ：

List(3, 4)

在上面的代码中，不需要命名元素。该元素通过 a_ 以较短的形式引用。也不需要限定方法调用。