函数式编程

基本理解

函数式编程的特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

常规方法	函数式编程
需要返回结果交给下一个函数	直接将函数传入,在其中进行调用
开始执行第一步就需要先进行计算	最后在传入所需处理内容,进行计算
线程可能不安全	无状态 线程安全

WIKI 但是实际工作量没变甚至还会增加（只有在真正想要最后的执行结果时我才去计算，大概就是惰性求值）

使用方法

基于函数接口实现:

其中 Cosumer 与 Supplier 对应，一个是消费者，一个是提供者。

Predicate 用于判断对象是否符合某个条件，经常被用来过滤对象。

Function 是将一个对象转换为另一个对象，如Function<T, R> T为入参 R为该函数的返回值 实现为传入的方法。

UnaryOperator 接收和返回同类型对象，一般用于对对象修改属性。BinaryOperator 则可以理解为合并对象。

传入函数方式 (以Function接口为例):

    public SplitServerImpl setUrlBeenFunction(Function<String, UrlBeen> urlBeenFunction) {
        this.urlBeenFunction = urlBeenFunction;
        return this;
    }

对于传入函数,通过该方法调用:

private Function<String, UrlBeen> urlBeenFunction;

urlBeenFunction.apply(requestUrl);

调用方式(与流结合使用):

.setUrlBeenFunction(url -> SplitUrl.urlToBeen(url))

Stream流

Stream 的方法分为两类。一类叫惰性求值(设置求值方法)，一类叫及早求值(入参)。

判断一个操作是惰性求值还是及早求值很简单：只需看它的返回值。如果返回值是 Stream，那么是惰性求值。其实可以这么理解，如果调用惰性求值方法，Stream 只是记录(仅仅是一个设置)下了这个惰性求值方法的过程，并没有去计算，等到调用及早求值方法后，就连同前面的一系列惰性求值方法顺序进行计算，返回结果。

通用形式为：

Stream.惰性求值.惰性求值. ... .惰性求值.及早求值

WIKI

整个过程和建造者模式有共通之处。建造者模式使用一系列操作设置属性和配置，最后调 用一个 build 方法，这时，对象才被真正创建。整个实现过程非常像建造者模式,

Bulider.creat() //new been
.setXX() //been的set方法
... //been各种方法(比如使用函数式编程操作)
.build(); //构建入参

p.s.建造者模式:

Client.creat() //new Builder
.setXX() //Builder的set方法/build方法
... //Builder各种set方法/build方法
.build(); //Builder的方法 new Client

也就是在Client中new Builder 之后再Builder中对入参进行处理 构建出一个所需数据结构 之后调用Builder.build()返回Client对象,之后在Client中使用builder.XX进行取值.

@FunctionalInterface

每个用作函数接口的接口都应该添加这个注释。

但 Java 中有一些接口，虽然只含一个方法，但并不是为了使用 Lambda 表达式来实现的。比如，有些对象内部可能保存着某种状态，使用带有一个方法的接口可能纯属巧合。

该注释会强制 javac 检查一个接口是否符合函数接口的标准。如果该注释添加给一个枚举类型、类或另一个注释，或者接口包含不止一个抽象方法，javac 就会报错。重构代码时，使用它能很容易发现问题。

 

最后的最后:为什么?

函数式编程对于没有学过的人来说并不容易理解,且相对于传统编程开销反而会增加(JIT 编译器对于函数式代码会编译出更慢的程序) 那为什么还要使用函数式编程呢? Java对其支持肯定存在即合理,除此之外我认为以下两点最为主要:

1.更方便的代码管理

函数式编程不依赖、也不会改变外界的状态，只要给定输入参数，返回的结果必定相同。因此，每一个函数都可以被看做独立单元，很有利于进行单元测试（unit testing）和除错（debugging），以及模块化组合。

2.易于"并发编程"

函数式编程不需要考虑"死锁"（deadlock），因为它不修改变量，所以根本不存在"锁"线程的问题。不必担心一个线程的数据，被另一个线程修改，所以可以很放心地把工作分摊到多个线程，部署"并发编程"（concurrency）。

WIKI 无状态

函数编程中函数保持独立，所有功能就是返回一个新的值，没有其他行为，尤其是不得修改外部变量的值。

函数式编程只是返回新的值，不修改系统变量。因此，不修改变量，也是它的一个重要特点。

在其他类型的语言中，变量往往用来保存"状态"（state）。不修改变量，意味着状态不能保存在变量中。函数式编程使用参数保存状态，最好的例子就是递归。如:

　　function reverse(string s) {
　　　　if(s.length == 0) {
　　　　　　return s;
　　　　} else {
　　　　　　return reverse(s.substring(1, string.length)) + s.substring(0, 1);
　　　　}
　　}

由于使用了递归，函数式语言的运行速度比较慢，这是它长期不能在业界推广的主要原因。

而对并发的支持,请看下面的代码：

　　var s1 = Op1();

　　var s2 = Op2();

　　var s3 = concat(s1, s2);

由于s1和s2互不干扰，不会修改变量，谁先执行是无所谓的，所以可以放心地增加线程，把它们分配在两个线程上完成。其他类型的语言就做不到这一点，因为s1可能会修改系统状态，而s2可能会用到这些状态，所以必须保证s2在s1之后运行，自然也就不能部署到其他线程上了。

多核CPU是将来的潮流，所以函数式编程的这个特性非常重要