Java 函数式编程（1）

Introduction:

函数式编程语言操作一段代码和操作数据一样简单。尽管Java不是一个functional language，但是Java 8 的 Lambda 表达式 (Lambda Expression) 和 方法引用 (Method Reference) 允许你以一种函数式的方式编程。

从代码创造，维护和可靠性的角度来看，使用代码去操作其他代码是令人难以抗拒的。如果可以利用现有的，经过测试的，可靠的代码，而不是从0开始写代码。把你的新代码和现有的代码组合起来创造新的功能，那会使我们更加高效的同时，创造更加健壮的代码，这就是函数式编程！

OO abstracts data, FP abstracts behavior. (面向对象抽象数据，函数式编程抽象行为）

纯函数语言为了安全，强制所有的data都是不可变的（一旦初始化了，那么就不再改变了，类似String）。所有被提交到方法的变量都只能产生一个新的值，不能（1. 改变传入的参数，2.不能改变方法外部的元素）。

这样的好处：

1. 避免了 side effect，所有的方法都是直接返回一个值，不改变什么别的东西。

2. 在多线程中，当你的代码在多个处理器上跑的时候，可能会去修改同一块内存地址。如果是纯函数式编程（不变性）那么所有的局部变量，入参都在私有的栈帧中就不会产生竞争问题。

OLD vs New

情景：一个方法通常来说，相同的输入会有相同的输出。如果我们想要让它有不同的输出怎么办，我们可以传一段代码给这个方法来控制它的行为。（使用代码去操作其他代码）

package com.jos.functional;

interface Strategy{
    String approach (String msg);
}

class Soft implements Strategy{

    @Override
    public String approach(String msg) {
        return msg.toLowerCase() + "?";
    }
}

class Unrelated{
    static String twice(String msg) {
        return msg + " " + msg;
    }
}

public class Strategize {
    Strategy strategy;
    String msg;

    public Strategize(String msg) {
        this.strategy = new Soft();
        this.msg = msg;
    }

    void communicate(){
        System.out.println(strategy.approach(msg));
    }

    void changeStrategy(Strategy strategy){
        this.strategy = strategy;
    }

    public static void main(String[] args) {
        Strategize s = new Strategize("Hello there");

        Strategy [] strategies ={
                new Strategy() {
                    @Override
                    public String approach(String msg) {
                        return msg.toUpperCase() + "!";
                    }
                },
                msg1 -> msg1.substring(0, 5),
                Unrelated::twice
        };
        s.communicate();

        for (Strategy strategy : strategies) {
            s.changeStrategy(strategy);
            s.communicate();
        }
    }
}

 这段代码我们通过传递行为，而不只是传递数据的方式来实现（同样的一段字符串，但是输出不同的内容）

1. Soft: 实现接口，默认的策略，直接赋值给了构造方法

2. 匿名类（）冗长

3. lambda 表达式，和匿名类一样效果，但是更加简洁

4. 方法引用（简洁） 类名/对象名::方法