Lambda 表达式
最早接触到 Lambda 表达式的时候，是在学习 python 的时候，当时就很好奇。后来，才发现 Java 也有这个方面的知识，最近看了相关的知识，特定来总结一下。
Lambada 简介
lambda 表达式 是Java 8新加入的新特性，它在Java中是引入了函数式编程这一概念。那么什么是函数式编程呢？
函数式编程：函数式编程是面向数学的抽象，将计算描述为一种表达式求值。
我们平常所说的面向对象编程属于命令式编程，函数式编程和命令式编程的区别是：
- 函数式编程关心数据的映射，命令式编程关系解决问题的步骤。
- 函数式编程关系类型（代数结构）之间的关系，命令式编程关系解决问题的步骤。
函数式编程的本质：
函数式编程中的函数指的不是计算机中的函数，而是数学中的函数，即自变量的映射。即：一个函数的值仅取决于函数参数的值，不依赖其他状态。
严格意义上的函数式编程意味着不使用可变的变量，赋值，循环和其他命令式控制结构进行编程。
函数式编程的好处：
函数式编程的好处是主要是不可变性带来的。没有可变的状态，函数就是引用透明（Referential transparency）的和没有副作用的（No Side Effect）。
上面这些都是一些基本的概念，但是我们平时可能接触这些方面的东西比较少，所以一开始感觉函数式编程是很难得东西。
简单的示例
Talk is cheap, show me the code!
先来一个最简单的例子，可能也是介绍的最多的例子了。哈哈！
给按钮添加监视器。
使用匿名内部类的方式，进行添加。
submit.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);
}
});
这种方式的缺点：使用了很多的模板代码，真正必要的代码，只是方法体内的代码。所以，Java 8 引入的 Lambda 表达式可以简化这种代码（当然了，也是有限制的，不是所有的匿名内部类都可以，这个后面会提到。）。
使用 Lambda 表达式 简化代码
submit.addActionListener((e)->{
JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);
});
Lambda 表达式是一个匿名方法，将行为像数据一样进行传递。
说明
可以看出来，使用 Lambda 表达式简化后的代码表达变得更加清晰了，并且不用再去写繁琐的模板代码了。
进一步简化
参数括号和代码体的花括号也可以省略（只有一个参数时，可以省略圆括号，只有一行代码时，可以省略花括号）。
ActionListener listener = e->JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);小结
当使用 Lambda 表达式代替匿名内部类创建对象时，Lambda 表达式的代码块将会替代实现抽象方法的方法体，Lambda 就相当于一个匿名方法。
Lambda 表达式的组成部分
lambda 表达式由三部分组成：
- 形参列表。形参列表允许省略形参类型。如果形参列表中只有一个参数，可以省略形参列表的圆括号。
- 箭头（->）。英文短线和大于号。
- 代码块。如果代码块只有一句，可以省略花括号。如果只有一条
return语句，可以省略return，lambda表达式会自动返回这条语句的值。
注：
之所以可以省略形参列表是因为 编译器 可以进行类型推断，例如：
List<Dog> dogs1 = new ArrayList<Dog>();
List<Dog> dogs2 = new ArrayList<>();
上面使用 菱形语法，可以省略尖括号里面的东西，这就是类型推断的作用。
但是类型推断也不是万能的，不是所有的都可以推断出来的，所以有时候，还是要显示的添加形参类型，例如：
先不要管这个代码的具体作用。
BinaryOperator b = (x, y)->x*y;
//上面这句代码无法通过编译，下面是报错信息：无法将 * 运算符作用于 java.lang.Object 类型。
The operator * is undefined for the argument type(s) java.lang.Object, java.lang.Object
//添加参数类型，正确的代码。
BinaryOperator<Integer> b = (x, y)->x*y;
所以，类型推断不是万能的，如果编译器无法推断，那就是我们的错误，不要过度依赖编译器。有时候，显示的添加参数类型，还是很必要的，当然了，这需要去多练习。
函数式接口
前面了解了，Lambda 表达式可以代替匿名内部类，进而达到简化代码，表达清晰的目的。那么使用 Lambda 表示式的前提是什么呢？-- 函数式接口
Lambda 表达式的类型，也被称为 目标类型 （Target Type），它必须是一个函数式接口（Functional Interface）。所谓函数式接口，指的就是：只包含一个抽象方法的接口。（可以包含多个默认方法，静态方法，但必须只有一个抽象方法）。
注：Java 8 专门提供了一个注解：@FunctionalInterface。用于标注某个接口是函数式接口，这样编译时就会检查，如果该接口含有多个抽象方法，编译器就会报错。
上面使用 Lambda 表达式来为按钮添加了监视器，可以看出来，Lambda 表达式 代替了 new ActionListener()对象。
所以 Lambda 的表达式就是被当成一个对象。
例如：
ActionListener listener = e->JOptionPane.showMessageDialog(null, "点击了确定按钮", "确定", JOptionPane.INFORMATION_MESSAGE);
从上面这个例子中可以看出来，Lambda 表达式实现的是匿名方法–因此它只能实现特定函数式接口中的唯一方法。
所以 Lambda 表达式有下面两种限制：
Lambda 表达式的目标类型必须是明确的函数式接口。 Lambda 表达式只能为函数式接口创建对象。Lambda只能实现一个方法，因此它只能为含有一个抽象方法的接口（函数式接口）创建对象。
介绍几个 Java 中重要的函数接口
从这种表可以看出来，抽象方法的名字反而不是最重要的了，重要的是参数和返回值。 因为在写 Lambda 表达式的时候，也不要使用 抽象方法名了。
上面使用几个简单的例子来说明上面接口的应用：
测试代码
import java.text.ParseException;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.UnaryOperator;
import java.util.stream.Stream;
public class Test {
public static void main(String[] args) throws ParseException {
//Lambda 表达式中的构造器引用，用于简化代码。
Creat<Dog> c = Dog::new;
Dog dog = c.creat("小黑", 15);
System.out.println(dog.toString());
Predicate<String> predicate = (words)->{
return words.length() > 20;
};
assert predicate.test("I love you yesterday and today!") : "长度小于20";
assert !predicate.test("God bless you!") : "长度小于20";
System.out.println("------------------------");
Consumer<Dog> consumer = System.out::println;
consumer.accept(dog);
System.out.println("------------------------");
Function<Dog, String> function = (dogObj)->{
return dogObj.getName();
};
System.out.println(function.apply(dog));
System.out.println("------------------------");
Supplier<Dog> supplier = ()->{
return new Dog("大黄", 4);
};
System.out.println(supplier.get());
//一元操作符
UnaryOperator<Boolean> unaryOperation = (flag)->{
return !flag;
};
System.out.println(unaryOperation.apply(true));
BinaryOperator<Integer> binaryOperator = (x, y)->x*y;
int result = binaryOperator.apply(999, 9999);
System.out.println(result);
}
}
测试使用的实体类
public class Dog {
private String name;
private int age;
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Dog [name=" + name + ", age=" + age + "]";
}
}
自定义函数式接口
@FunctionalInterface
public interface Creat<T> {
public T creat(String name, int age);
}
运行截图就不放了，感兴趣的可以试一下。
说明
我这里直接使用 Lambda 创建了对象，然后调用了这个对象的方法（就是lambda 的代码块部分），真正使用的时候，都是直接传递 Lambda 表达式的，这种方法并不推荐，但是可以让我们很好的理解为什么？ 可以看出来，Lambda 表达式的作用，最后还是需要调用 重写的抽象方法的，只不过使用表达更加清晰，简化了代码。
例如：
List<Dog> dogs = new ArrayList<>();
dogs.add(new Dog("大黄", 2));
dogs.add(new Dog("小黑", 3));
dogs.add(new Dog("小哈",1));
//将行为像数据一样传递，使用集合的 forEach 方法来遍历集合，
//参数可以是一个 Lambda 表达式。
Consumer<? super Dog> con = (e)->{
System.out.println(e);
};
dogs.forEach(con);
System.out.println("--------------------------\n");
//直接传递 Lambda 表达式，更加简洁
dogs.forEach(e->System.out.println(e));
System.out.println("--------------------------\n");
//使用方法引用，进一步简化（可以看我的另一篇关于方法引用的博客）
dogs.forEach(System.out::println);
System.out.println("--------------------------\n");
//使用 Lambda 对集合进行定制排序，按照年龄排序（从小到大）。
dogs.sort((e1, e2)->e1.getAge()-e2.getAge());
dogs.forEach(System.out::println);
可以看出来，通过使用 Lambda 表达式可以，极大的简化代码，更加方便的操作集合。值得一提的是：Lambda 表达式 和 Stream 的结合，可以拥有更加丰富的操作，这也是下一步学习的方向。
运行截图：
最后说一下
这个博客介绍了一些 Lambda 表达式的基本知识，但是描述的还是不是很清楚，哈哈！但是，希望通过这个简单的博客，可以帮助了解一些关于 Lambda 表达式的基本知识，这些都是很简单的东西，太难的部分，我可能暂时还没有触及到。
Lambda 表达式是一个匿名方法，将行为像数据一样进行传递。
这句话很关键，这是对 Lambda 的一个很好的总结。
到此这篇关于详细解读Java的Lambda表达式的文章就介绍到这了,更多相关Java Lambda表达式内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！
