函数式编程

在算法中使用fold

使用fold函数可以将序列或集合规约为单个值
fold函数是一种规约操作，可以应用于数组或可迭代对象
fold函数有两个参数，一个是累加器的初始值，另一个是带有两个参数的函数，返回累加新值。经典实例是求和：

    fun sun (vararg nums :Int) = 
        nums.fold(0){acc,n->acc+n}

    fun sun (vararg nums :Int) = 
        nums.fold(0){acc,n->
            println("acc = $acc,n= $n")
            acc+n
        }
val numbers = intArrayOf(3,1,4,1,5,9)
sum(*numbers)

结果是：

acc = 0,n = 3
acc = 3,n = 1
acc = 4,n = 4
acc = 8,n = 1
acc = 9,n = 5
acc = 14,n = 9

变量acc被初始化为fold的第一个参数，变量n接收集合的每个元素，而lambda表达式的结果acc+n是每次迭代中acc的新值。

使用reduce函数进行归约

reduce函数与fold函数几乎完全相同。
最大区别是，reduce没有为累加器提供初始值的参数，因此累加器使用集合中第一个值进行初始化。
空集合结果对应的结果是抛出异常。

fun dumReduce(vararg nums:Int) = 
    nums.reduce{acc,i -> acc +i}

使用reduce可能有另一种出错方式。假设求和之前先乘2，但是reduce第一个用于初始化累加器没有乘2，最后出错。
仅当可用集合的第一个值初始化累加器且对其他值不执行任何其他处理时才是用reduce

使用尾递归

添加tailrec关键字

一般阶乘的递归实现

fun recursiveFactorial(n:Long):BigInteger  =
    when(n){
        0L,1L -> BigInteger.ONE
        else -> BigInteger.valueOf(n)*recursiveFactorial(n-1)
    }

每一次递归都会将新栈添加到调用栈，以至于最后该进程可能会内存溢出。（OpenJdk 1.8上默认为1024字节）

尾递归无需将新栈添加到调用栈即可实现。

@JvmOverloads    //该注解允许在java中只使用一个参数调用该函数
tailrec fun factorial(n:Long,acc:BigInteger = BigInteger.ONE):BigInteger =
    when(n){
        0L -> BigInteger.ONE
        1L -> acc
        else - > factorial(n-1,acc*BigInteger.valueOf(n))
    }

上面方法反编译java如下

public static final BigInteger factorial(long n,BigInteget acc){
    while(true){
        BigInteger result;
        if(n==0L){
            result = BigInteger.ONE;
        }else{
            if(n!=1L){
                result = result.multiply(BigInteger.valueOf(n));
                n = n-1L;
                continue;
            }
        }
        return result;
    }
}

使用tailrec修饰符的使用规则：
该函数必须将调用它自己作为最后一步操作
不能再try/catch/finally中使用
尾递归仅在JVM后端支持