目录
参考地址：https://blog.csdn.net/lcgoing/article/details/87886599
参考地址：https://www.jianshu.com/p/95b168bea405
函数式编程的概念
函数式编程是种编程方式，它将电脑运算视为函数的计算。函数编程语言最重要的基础是λ演算（lambda calculus），而且λ演算的函数可以接受函数当作输入（参数）和输出（返回值）。和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。和过程化编程相比，函数式编程里函数的计算可随时调用。
函数式编程的优缺点：
优点:
- 代码简洁，开发快速：函数式编程大量使用函数，减少了代码的重复，因此程序比较短，开发速度较快。
- 接近自然语言，易于理解：函数式编程的自由度很高，可以写出很接近自然语言的代码。将表达式(1 + 2) * 3 - 4，写成函数式语言：subtract(multiply(add(1,2), 3), 4)
- 更方便的代码管理：函数式编程不依赖、也不会改变外界的状态，只要给定输入参数，返回的结果必定相同。因此，每一个函数都可以被看做独立单元，很有利于进行单元测试（unit testing）和除错（debugging），以及模块化组合。
- 易于"并发编程"：函数式编程不需要考虑"死锁"（deadlock），因为它不修改变量，所以根本不存在"锁"线程的问题。不必担心一个线程的数据，被另一个线程修改，所以可以很放心地把工作分摊到多个线程，部署"并发编程"（concurrency）。
- 代码的热升级：函数式编程没有副作用，只要保证接口不变，内部实现是外部无关的。所以，可以在运行状态下直接升级代码，不需要重启，也不需要停机。
缺点：
- 函数式编程常被认为严重耗费在CPU和存储器资源。早期的函数式编程语言实现时并无考虑过效率问题；有些非函数式编程语言为求提升速度，不提供自动边界检查或自动垃圾回收等功能；惰性求值亦为语言增加了额外的管理工作。
- 因为其灵活的语法控制不好程序的结构，带来了语言学习难度高，代码维护性差等缺点。
Lambda表达式
Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
优点：
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
缺点：
- 用Lambda充当匿名内部类、方法引用等场合效率低
- Lambda的特点还在于开发成本高，并且异常难以排查。它的异常堆栈比匿名内部类还要难懂。如果你把stream的操作都写在同一行，则问题更甚。
- 代码维护性差。
Lambda表达式的语法
Java8中Lambda表达式由三个部分组成：
第一部分为一个括号内用逗号分隔的形式参数，参数是函数式接口里面方法的参数
第二部分为一个箭头符号: ->;
第三部分是方法体，可以是表达式和代码块。
1.方法体为表达式时，该表达式的值作为返回值返回
(parameters) -> expression
//求和
(int a,int b) -> return a + b;2.方法体为代码块，必须用{ }来包裹起来，且需要一个return返回值，但函数式接口里面方法返回值是 void，无需返回值。
(parameters) -> { statements; }
//求平方
(int a) -> {return a * a;}
//打印，无返回值
(int a) -> {System.out.println("a = " + a);}lambda表达式的函数式接口
- 函数式接口(Functional Interface)是Java 8对一类特殊类型的接口的称呼。这类接口只定义了唯一的抽象方法的接口（除了隐含的Object对象的公共方法，因此最开始也就做SAM类型的接口（Single Abstract Method）。
- 定义函数式接口的原因是在Java Lambda的实现中,开发组不想再为Lambda表达式单独定义一种特殊的Structural函数类型,称之为箭头类型（arrow type,依然想采用Java既有的类型(class, interface, method等)。
- 增加一个结构化的函数类型会增加函数类型的复杂性，破坏既有的Java类型，并对成千上万的Java类库造成严重的影响。权衡利弊,因此最终还是利用SAM 接口作为 Lambda表达式的目标类型。
- 对于函数式接口来说@FunctionalInterface并不是必须的,只要接口中只定义了唯一的抽象方法的接口那它就是一个实质上的函数式接口,就可以用来实现Lambda表达式。
Java8中已经定义了很多常用的函数式接口，他们都放在java.util.function包下面，一般有以下常用的四大核心接口：
| 函数式接口 | 参数类型 | 返回类型 | 用途 |
| Consumer<T>(消费型接口) | T | void | 对类型为T的对象应用操作，void accept(T t) |
| Supplier<T>(供给型接口) | 无 | T | 返回类型为T的对象 T get(); |
| Function<T, R>(函数型接口) | T | R | 对类型为T的对象应用操作并返回R类型的对象。R apply(T t); |
| Predicate<T>(断言型接口) | T | boolean | 确定类型为T的对象是否满足约束，boolean test(T t); |
Lambda具体应用场景
当我们新建一个线程的时候，以前我们可以这样做：
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(666);
}
});改为lambda表达式后
Thread t1 = new Thread(() -> System.out.println("hello world"));是不是觉异常简单。
函数式接口
只有函数式接口，才可以转换为lambda表达式，什么是函数式接口呢？
- 有且只有一个抽象方法的接口被成为函数式接口！
- 函数式接口可以显式的被@FunctionalInterface所表示，当被标识的接口不满足规定时，编译器会提示报错
我们所熟知的Runnable就是一个函数式接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}1、当函数式接口内的唯一抽象方法没有参数时，可以使用如下方式
//如果方法体内只有一条语句
//1.无返回值
() -> System.out.println("test");
//2.有返回值，不需要显示的return
() -> new Student();
//3.如果有多条语句，需要用{}包围
//无返回值
() -> {
int a = 1;
int b = 2;
System.out.println(a * b);
};
//4.有返回值
() -> {
int a = 1;
int b = 2;
return a * b;
};2、当函数式接口内的唯一抽象方法含有参数时，写法与上面基本相同，只是需要把对应参数写入到()里面
//不需要指明参数类型，会根据实际方法中的类型自动推测
//只有一个参数可以省略括号
(arg1, arg2, arg3) -> System.out.println(arg1 * arg2 * arg3);3、举个例子
//自定义一个函数式接口
@FunctionalInterface
public interface MyInterface {
void method(int a, int b);
}
//使用lambda表达式
public static void main(String[] args) {
MyInterface myInterface = (a, b) -> System.out.println(a + b);
myInterface.method(1, 2);//3
}意义
首先毋庸置疑，lambda表达式十分简洁。其次，在传统的java面向对象编程中，我们在方法内只可以传递值或对象引用，无法传递方法。当我们想要在方法中传递方法，或者说是传递行为的时候，如Java Swing或者Android开发中，经常需要我们实现监听接口中的方法，这就是一种行为的传递。
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
//代码省略
}
};
这种行为的传递需要依赖接口实现类实例，但是我们只关心方法内部的逻辑实现，所以使用lambda表达式可以实现这一目标
private Handler handler = msg -> {
//代码省略
};
//但实际上lambda并没有脱离接口，仍然依附于接口实现类实例
Java8内置的函数式接口
Java8提供了一个java.util.function包，包含了很多函数式接口，我们来介绍最为基本的4个（为了节省篇幅，去掉了源码中的注释）
Function接口
@FunctionalInterface
public interface Function<T, R> {
R apply(T t);
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
static <T> Function<T, T> identity() {
return t -> t;
}
}
Function接口的唯一抽象方法是apply，作用是接收一个指定类型的参数，返回一个指定类型的结果
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
FunctionTest ft = new FunctionTest();
//使用lambda表达式实现apply方法，返回入参+10。形式上如同传递了一个方法作为参数
int res = ft.compute(1, v -> v + 10);
System.out.println(res);//11
}
public int compute(int a, Function<Integer, Integer> function){
//使用者在使用本方法时，需要去编写自己的apply，
//传递的funtion是一个行为方法，而不是一个值
return function.apply(a);
}
默认方法compose作用是传入参数后，首先执行compose方法内的Function的apply方法，然后将其返回值作为本Function方法的入参，调用apply后得到最后返回值
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
FunctionTest ft = new FunctionTest();
//调用compose
//先+8，然后将得到的值*3
System.out.println(ft.compute(2, v -> v * 3, v -> v + 8));//30
}
public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2){
//将function2先接收入参a，调用apply后，将返回值作为新的入参，传入function1，调用apply返回最后结果
return function1.compose(function2).apply(a);
}
默认方法andThen与compose正好相反，先执行本Function的apply，然后将结果作为andThen方法参数内的Function的入参，调用apply后返回最后结果
import java.util.function.Function;
public class FunctionTest {
public static void main(String[] args) {
FunctionTest ft = new FunctionTest();
//调用andThen
//先*3，然后将得到的值+8
System.out.println(ft.compute(2, v -> v * 3, v -> v + 8));//14
}
public int compute(int a, Function<Integer, Integer> function1, Function<Integer, Integer> function2){
//将function2先接收入参a，调用apply后，将返回值作为新的入参，传入function1，调用apply返回最后结果
return function1.andThen(function2).apply(a);
}
静态方法identity的作用是传入啥返回啥，这里就不写例子了
Consumer接口
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
}
Consumer接口中accept方法的作用是接收指定参数类型，无返回值，重点在于内部消费
Consumer<String> consumer = s -> System.out.println("hello " + s);
consumer.accept("mike");// hello mike
默认方法andThen作用是连续消费，从本Consumer开始，从外到内，针对同一入参。
Consumer<String> consumer = s -> System.out.println("hello " + s);
Consumer<String> consumer2 = s -> System.out.println("nice to meet you " + s);
consumer.andThen(consumer2).accept("mike");
//hello mike
//nice to meet you mike
Predicate接口
package java.util.function;
import java.util.Objects;
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
Predicate中的test方法，传入指定类型参数，返回布尔类型的结果，用于判断，断言
//判断一个数是否是偶数
Predicate<Integer> predicate = b -> n % 2 == 0;
System.out.println(predicate.test(3));
//false
默认方法and顾名思义，将本Predicate和and参数中的Predicate对同一入参进行test的结果进行【与】操作。
negate方法对test的结果进行【非】操作
or方法对两个Predicate的test结果进行【或】操作
静态方法isEqual将其入参与test方法的入参进行equals比较
System.out.println(Predicate.isEqual(1).test(1));//true
Supplier接口
package java.util.function;
@FunctionalInterface
public interface Supplier<T> {
T get();
}
Supplier意为供应，只有一个方法get，不接收任何参数，只返回指定类型结果
Supplier<String> sup = () -> "hello world";
System.out.println(sup.get());
总结
以上就是function包中最为基础的四个函数式接口，不管是接口名称还是方法名称，都是见名知意，十分形象。
当然funtion包下还有很多其他接口，但基本都与这四个接口有关。如BiFunction是接收两个参数，DoubleConsumer是强制接收double类型的参数，更多函数式接口点进去源码一看注释便知道如何使用！
590
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
