Scala 规约列表的不同写法-CSDN博客

Scala 规约列表（Reducing）的意思是将列表转换为单个值。

自带版本

如使用 List 自带的操作符号

    List(41, 234, 23).max                         //> res3: Int = 234
    List(11.3, 23).sum                            //> res4: Double = 34.3

自定义版本

也可以自己实现这种规约操作函数

    def contains(x: Int, l: List[Int]): Boolean = {
        var a: Boolean = false
        for (i <- l) { if (!a) a = (i == x) }
        a
    }                                             //> contains: (x: Int, l: List[Int])Boolean
    contains(3, List(1, 3, 5, 7))                 //> res5: Boolean = true

函数参数版本

但对 List 的操作只能是判断是否含有某个函数，如果想进行多个操作，就可以自己传入函数定义

    def boolReduce(l: List[Int], start: Boolean)(f: (Boolean, Int) => Boolean): Boolean = {
        var a = start
        for (i <- l) a = f(a, i)
        a
    }      //> boolReduce: (l: List[Int], start: Boolean)(f: (Boolean, Int) 
                                                  //=> Boolean)Boo
                                                  //| lean
    boolReduce(List(1, 3, 5, 19), false)({(a, i) => if (a) a else (i == 19)})
                                                  //> res6: Boolean = true

泛型版本

这样可以传入自己定义的函数，进一步的可以将参数泛型化

    def reduceOp[A, B](l: List[A], start: B)(f: (B, A) => B): B = {
        var a =start
        for (i <- l) a = f(a, i)
        a
    }                   //> reduceOp: [A, B](l: List[A], start: B)(f: (B, A) => B)B
    reduceOp(List(1, 3, 5, 19), false)({(a, i) =>if (a) a else (i == 19)})
                                                  //> res7: Boolean = true
    reduceOp(List(1.2, 3.3, 2.3), 0.0)({(a, i) => a + i})
                                                  //> res8: Double = 6.8
    reduceOp(List(1.2, 3.3, 2.3), 0.0)(_ + _)     //> res9: Double = 6.8

等价于 Scala 自带方法

List(1.2, 3.3, 2.3).fold(0.0)(_ + _)          //> res10: Double = 6.8

reduceOp 可以传入不同的函数实现不同的功能，同时参数也可以自动推导出来。

转载于:https://my.oschina.net/lvyi/blog/801575