以前看到别人的Java代码里有泛型了，接口了，就特别害怕，不知道是干啥的，虽然上网也查了一些资料，但觉得还是理解的不够深入，导致遇到同样的问题，还是得重新查一遍资料。
Lambda表达式
这个几把玩意出现了好多次了，自己感觉实现同样的功能，用原来的代码写法就可以了嘛，为啥非得用这个东西呢？就算查资料去尝试学习它，自己的内心对它还是有抵触情绪的。直到公司的项目里同事的代码出现了Lambda写法，不学不行了，要不会影响对项目代码的理解的，就生出了再学习它一下的意图。
为啥需要Lambda？
学习一项技术，一定要知道它出现是解决什么问题的，不能知其然而不知其所以然。
Java 是一流的面向对象语言，除了部分简单数据类型，Java 中的一切都是对象，即使数组也是一种对象，每个类创建的实例也是对象。在 Java 中定义的函数或方法不可能完全独立，也不能将方法作为参数或返回一个方法给实例。
从 Swing 开始，我们总是通过匿名类给方法传递函数功能，以下是旧版的事件监听代码：
someObject.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
//Event listener implementation goes here...
}
});
在上面的例子里，为了给 Mouse 监听器添加自定义代码，我们定义了一个匿名内部类 MouseAdapter 并创建了它的对象，通过这种方式，我们将一些函数功能传给 addMouseListener 方法。
简而言之，在 Java 里将普通的方法或函数像参数一样传值并不简单，为此，Java 8 增加了一个语言级的新特性，名为 Lambda 表达式。Lambda 表达式是一种匿名函数(对 Java 而言这并不完全正确，但现在姑且这么认为)，简单地说，它是没有声明的方法，也即没有访问修饰符、返回值声明和名字。
Java 中的 Lambda 表达式通常使用 (argument) -> (body) 语法书写，例如：
(arg1, arg2...) -> { body }
(type1 arg1, type2 arg2...) -> { body }
以下是一些 Lambda 表达式的例子：
(int a, int b) -> { return a + b; }
() -> System.out.println("Hello World");
(String s) -> { System.out.println(s); }
() -> 42
() -> { return 3.1415 };
让我们了解一下 Lambda 表达式的结构：
- 一个 Lambda 表达式可以有零个或多个参数
- 参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同
- 所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)
- 空圆括号代表参数集为空。例如：() -> 42
- 当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> return a*a
- Lambda 表达式的主体可包含零条或多条语句
- 如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致
- 如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空。
什么是函数式接口 ?
在 Java 中，Marker（标记）类型的接口是一种没有方法或属性声明的接口，简单地说，marker 接口是空接口。相似地，函数式接口是只包含一个抽象方法声明的接口。
扩展
1、什么是标记接口？
一个空的接口称为标记接口（Tag Interface），Java中很多标记接口，比如Serializable，EventListener， Remote(java.rmi.Remote)等。
package java.util;
public interface EventListener{
}
2、 标记接口有什么特点？
标记接口没有任何成员变量和方法，它就是空的。你肯定疑惑，既然是空的，其他类怎么去实现（implement）它？它用来做什么？
实际上，其他类implement它是为了声明该类在某个特定集合中的成员资格，比如当一个类实现（implement）了Serializable接口，它的目的是声明其是Serializable中的一个成员，当JVM虚拟机看到该类是Serializable的，那么它在处理序列化／反序列化时会做一些特殊的处理。
标记接口对JVM是很有意义，你可以创建自己的标记接口来分离或分类代码，从而提高代码的可阅读行。
java.lang.Runnable 就是一种函数式接口，在 Runnable 接口中只声明了一个方法 void run()，相似地，ActionListener 接口也是一种函数式接口，我们使用匿名内部类来实例化函数式接口的对象，有了 Lambda 表达式，这一方式可以得到简化。
每个 Lambda 表达式都能隐式地赋值给函数式接口，例如，我们可以通过 Lambda 表达式创建 Runnable 接口的引用。
Runnable r = () -> System.out.println("hello world");
当不指明函数式接口时，编译器会自动解释这种转化
new Thread(
() -> System.out.println("hello world")
).start();
因此，在上面的代码中，编译器会自动推断：根据线程类的构造函数签名 public Thread(Runnable r) { }，将该 Lambda 表达式赋给 Runnable 接口。
@FunctionalInterface 是 Java 8 新加入的一种接口，用于指明该接口类型声明是根据 Java 语言规范定义的函数式接口。常见的函数式接口，比如Function，Consumer，Predicate，Supplier都是用@FunctionalInterface进行声明的。
以下是一种自定义的函数式接口：
@FunctionalInterface
public interface WorkerInterface {
public void doSomeWork();
}
根据定义，函数式接口只能有一个抽象方法，如果你尝试添加第二个抽象方法，将抛出编译时错误。例如：
@FunctionalInterface
public interface WorkerInterface {
public void doSomeWork();
public void doSomeMoreWork();
}
错误：
Unexpected @FunctionalInterface annotation
@FunctionalInterface ^ WorkerInterface is not a functional interface multiple
non-overriding abstract methods found in interface WorkerInterface 1 error
函数式接口定义好后，我们可以在 API 中使用它，同时利用 Lambda 表达式。例如：
//定义一个函数式接口
@FunctionalInterface
public interface WorkerInterface {
public void doSomeWork();
}
public class WorkerInterfaceTest {
public static void execute(WorkerInterface worker) {
worker.doSomeWork();
}
public static void main(String [] args) {
//不用Lambda表达式的写法
execute(new WorkerInterface() {
@Override
public void doSomeWork() {
System.out.println("哈喽，华妹妹！");
}
});
//用Lambda表达式的写法
execute( () -> System.out.println("华妹妹，我用Lambda表达式向你问好！😘") );
}
}
输出：
哈喽，华妹妹！
华妹妹，我用Lambda表达式向你问好！😘
这上面的例子里，我们创建了自定义的函数式接口并与 Lambda 表达式一起使用。execute() 方法现在可以将 Lambda 表达式作为参数。
Lambda 表达式举例
学习 Lambda 表达式的最好方式是学习例子。
线程可以通过以下方法初始化：
//旧方法:
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello from thread");
}
}).start();
//新方法:
new Thread(
() -> System.out.println("Hello from thread")
).start();
事件处理可以使用 Java 8 的 Lambda 表达式解决。下面的代码中，我们将使用新旧两种方式向一个 UI 组件添加 ActionListener：
//Old way:
button.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
System.out.println("The button was clicked using old fashion code!");
}
});
//New way:
button.addActionListener( (e) -> {
System.out.println("The button was clicked. From Lambda expressions !");
});
还有一种情况下使用Lambda表达式是很爽的，在开始之前，我们先来了解一下Function，Consumer，Predicate，Supplier这几个Java中常用的函数式接口。
先看一下Function接口定义:
@FunctionalInterface
public interface Function<T, R>
接口接受两个泛型类型<T, R>.
再看一下接口定义的方法(非静态，非default)， 支持lambda表达式的接口只允许定义一个抽象方法(@FunctionalInterface注解的接口，只允许定义一个抽象方法)，只要记住这一点，你就不会弄混了。
R apply(T t);
/**
* T 入参类型, t 输入参数
* R 返回值类型
*/
OK，现在明确了， 该接口的lambda表达式应该是接受一个入参，最后要有一个返回值，写法应该是这样的: (x) -> {return y;}
如果你的lambda表达式非常简单，只有一行，那么你可以不写return，不加花括号{}，返回值后面可以不加分号。
下面就可以写example了，写一个简单的，再写一个标准的：
public void testFunction(){
//简单的,只有一行
Function<Integer, String> function1 = (x) -> "test result: " + x;
//标准的,有花括号, return, 分号.
Function<String, String> function2 = (x) -> {
return "after function1";
};
System.out.println(function1.apply(6));
System.out.println(function1.andThen(function2).apply(6));
}
OK，Function的例子写完了，接下来写其他的，其实原理懂了，其他的就都简单了，然后就是熟能生巧了。
再看看Supplier的接口定义，这个接口定义比较简单，我就都贴上来了
@FunctionalInterface
public interface Supplier<T> {
/**
* Gets a result.
*
* @return a result
*/
T get();
}
接口接受一个泛型<T>，接口方法是一个无参数的方法，有一个类型为T的返回值。 OK， 那么接口的lambda表达式应该是这样的: () -> { return something; }，好，下面来写一个example：
public void testSupplier(){
//简写
Supplier<String> supplier1 = () -> "Test supplier";
System.out.println(supplier1.get());
//标准格式
Supplier<Integer> supplier2 = () -> {
return 20;
};
System.out.println(supplier2.get() instanceof Integer);
}
到这里你或许有一点疑惑，这Supplier到底能用在哪啊？Java 8里新增了一个异步线程的类，很牛逼，很强大的类：CompletableFuture, 里面的很多方法的入参都用到的Supplier，例如： supplyAsync方法。 本文暂时不介绍CompletableFuture。
接下来是Consumer，我们来看一下接口的定义：
@FunctionalInterface
public interface Consumer<T>
然后再看一下里面的抽象方法:
void accept(T t);
现在了解了: 接口接受一个泛型<T>，接口方法是入参类型为T， 无返回值的方法, OK，下面开始写example:
public void testConsumer(){
Consumer<String> consumer1 = (x) -> System.out.print(x);
Consumer<String> consumer2 = (x) -> {
System.out.println(" after consumer 1");
};
consumer1.andThen(consumer2).accept("test consumer1");
}
接下来看一下Predicate接口
接口定义:
@FunctionalInterface
public interface Predicate<T>
抽象方法:
boolean test(T t);
接口接受一个泛型<T>, 接口方法的入参类型是T, 返回值是一个布尔值, OK, 下面写example:
public void testPredicate(){
Predicate<String> predicate = (x) -> x.length() > 0;
System.out.println(predicate.test("String"));
}
Predicate接口在stream里面用的比较多，感兴趣的可以去看看stream，java 8 里另一个新的东西，很好玩。
看完上面这几个接口的定义和用法，你会发现它们和其他普通的接口没啥不一样的，都只是声明，而不实现细节，唯一特殊之处，就是它被@FunctionalInterface修饰，支持Lambda表达式罢了！
回到刚才的那个话题，有一种情况下用Lambda是很爽的，看下面的代码：
先声明一个数组
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
如果我们要计算所有元素的和，怎么写代码？
public int sumAll(List<Integer> numbers) {
int total = 0;
for (int number : numbers) {
total += number;
}
return total;
}
又来个需求，如果只想计算所有偶数的和怎么写代码？我们会基于上面的代码，做一个判断：
public int sumAllEven(List<Integer> numbers) {
int total = 0;
for (int number : numbers) {
if (number % 2 == 0) {
total += number;
}
}
return total;
}
哈哈，又来几个需求，比如说计算只大于3的所有数之和，你是不是又得把刚才的代码粘贴过来，改叭改叭呢？
看看用Lambda怎么写的吧，结合Predicate使用
public int sumAll(List<Integer> numbers, Predicate<Integer> p) {
int total = 0;
for (int number : numbers) {
if (p.test(number)) {
total += number;
}
}
return total;
}
对应上面三个需求，分别调用：
sumAll(numbers, n -> true);
sumAll(numbers, n -> n % 2 == 0);
sumAll(numbers, n -> n > 3);
非常的灵活啊！先写到这里吧！
网友评论