Java8中引入了Lambda表达式，支持用户进行函数式编程，这是Java的一次重要性的革新（好吧，其实这不是啥新东西了，不更新跟不上潮流啊）
严格来讲函数式编程也不是什么很新颖的东西，它与我们现在主要使用的命令式编程最大的区分点在于
函数式编程更加强调程序执行的结果而非执行的过程，倡导利用若干简单的执行单元让计算结果不断渐进，逐层推导复杂的运算，而不是设计一个复杂的执行过程
简单来说，命令式编程更加注重运行过程，而函数式编程更加注重运行结果，因为在给定的函数下，只要输入相同，结果必然相同，各个函数之间是相互隔离的，这种优势在多线程环境下会被体现的淋漓尽致
我们可以用代码的方式查看两者的区别（这里使用JavaScript）
先书写一段普通的命令式编程代码
var a=3;
var b=4;
console.log((a+b)*2);
这应该是一段再简单不过的代码，下面来看看函数式编程的写法
function add(num1,num2){return num1+num2;};
function mutilply(num1,num2) {return num1*num2;};
function print(...args){console.log(arg[3](arg[2](arg[0],arg[1]),2)))};
print(3,4,add,mutilply);
可以看到，最明显的区别就是在函数也被看成一个变量，而不是简单的一个代码组合
函数式接口
Java是一门面向对象的语言，因此要实现函数式编程也只能以面向对象的方式去间接实现。在函数式编程中，函数也被看成一个独立的对象，而面向对象则是万物皆对象，因此在面向对象中实现函数式编程，必须满足以下条件
- 这个类只能有一个方法，没有任何属性
- 这个方法必须是抽象的
按照这样来看，用户要实现函数式编程，必须以单函数接口的方式去实现，并以匿名类的方式作为变量去传参，Java8中也新增了一个注解用来标注这种特殊接口
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FunctionalInterface {}
正如它的名字一样，函数式接口，在其Javadoc上有这样一段话
Note that instances of functional interfaces can be created with lambda expressions, method references, or constructor references.
很明显，这个注解是用来标识一个接口为函数式接口并且可以使用lambda表达式的方式去实例化，然而还有一句打脸的话
However, the compiler will treat any interface meeting the definition of a functional interface as a functional interface regardless of whether or not a {@code FunctionalInterface} annotation is present on the interface declaration.
也就是说这个注解你写不写无所谓，反正编译器都会把单抽象方法的接口看成函数式接口（wtf。。。）
Lamdba表达式
上面提到，在Java中使用函数式编程必须要使用匿名类的方式，下面来个demo
/**
* 尽管可以不使用{@code FunctionalInterface},但是还是建议大家使用，毕竟代码可读性好点
* @author 韩超
* @version 2019.04.14
* @link @FunctionalInterface
*/
@FunctionalInterface
public interface FuncationalInterfacesDemo {
void doSomething(Book book);
}
class Book {//实体类
private String name;
private float price;
public Book(String name, float price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public float getPrice() {
return price;
}
public void setPrice(float price) {
this.price = price;
}
}
class BookStore{
/**
* 自定义输出，输出方式由 FuncationalInterfacesDemo#doSomething 去实现
* @param book
* @param demo
*/
public static void customPrintBook(Book book,FuncationalInterfacesDemo demo){
demo.doSomething(book);
}
}
主函数如下
public static void main(String[] args){
Book book=new Book("书1",15.4f);
BookStore.customPrintBook(book, new FuncationalInterfacesDemo() {//第一种输出方式
@Override
public void doSomething(Book book) {
System.out.println("书名："+book.getName()+"| 价格："+book.getPrice());
}
});
BookStore.customPrintBook(book, new FuncationalInterfacesDemo() {//第一种输出方式
@Override
public void doSomething(Book book) {
System.out.println("书名："+book.getName()+"---价格："+book.getPrice());
}
});
}
这是一种比较常用的函数式编程实现方式，当然，这是Java8以前的做法，还记得提到过的Lambda表达式吗？用Lambda表达式去实现会更简单
//第一种输出方式
public static void main(String[] args){
Book book=new Book("书1",15.4f);
//第一种输出方式
BookStore.customPrintBook(book, book1 -> System.out.println("书名："+ book1.getName()+"| 价格："+ book1.getPrice()));
//第一种输出方式
BookStore.customPrintBook(book, book12 -> System.out.println("书名："+ book12.getName()+"---价格："+ book12.getPrice()));
}
在这里book1 -> System.out.println("书名："+ book1.getName()+"| 价格："+ book1.getPrice())就是Java引入的新特性之一Lamdba表达式,如果你不好理解,没关系,我帮你
FuncationalInterfacesDemo demo=new FuncationalInterfacesDemo() {
@Override
public void doSomething(Book book) {
System.out.println("书名："+book.getName()+"| 价格："+book.getPrice());
}
});
这是我们最初使用的方式,实际上可以做以下等价
demo=public void doSomething(Book book) {
System.out.println("书名："+book.getName()+"| 价格："+book.getPrice());
}
因为demo这个对象与其他FuncationalInterfaceDemo类对象的区别仅仅在于函数体的实现,实际上还可以更加简单
demo=void doSomething(Book book) {
System.out.println("书名："+book.getName()+"| 价格："+book.getPrice());
}
public声明很明显是多余的，不是public我怎么访问到你呢？但是似乎可以更简单
demo=void (Book book) {
System.out.println("书名："+book.getName()+"| 价格："+book.getPrice());
}
函数名也不重要，因为前面踢到函数式接口就一个抽象方法，既然就你一个是抽象的，为什么我要在乎你的名字呢？但是好像编译器可以帮我们自动判断返回值类型和参数类型...
demo=(book){System.out.println("书名："+book.getName()+"| 价格："+book.getPrice());}
但是这样可读性好差啊，算了吧，加个->吧，于是就变成了这样
demo=(book)->{System.out.println("书名："+book.getName()+"| 价格："+book.getPrice());}
这就是我所理解的Lambda表达式的转换过程，括号中的部分用于标识参数部分，花括号中的部分用于标识代码体,用->做分割，当然如果你只有一个参数和一行代码体，大可不需要括号和花括号
demo=book->System.out.println("书名："+book.getName()+"| 价格："+book.getPrice());
总结
Lamdba表达式归根到底只是一种语法糖，目的就是尽可能减少我们书写的代码行数，当然这也是Java8为后面推出的Stream API做的一个铺垫