共计 4510 个字符，预计需要花费 12 分钟才能阅读完成。
什么时候能够应用 Lambda？通常 Lambda 表达式是用在函数式接口上应用的。从 Java8 开始引入了函数式接口，其阐明比较简单: 函数式接口 (Functional Interface) 就是一个有且仅有一个形象办法，然而能够有多个非形象办法的接口。
3.1、语法定义
/**
- 定义函数式接口
- 接口上标注 @FunctionalInterface 注解
*/
@FunctionalInterface
public interface ICollectionService {
/**
- 定义打印办法
*/
void print();
}
在 Java8 以前，就已有大量函数式接口如下:
- java.lang.Runnable
- java.util.concurrent.Callable
- java.security.PrivilegedAction
- java.io.FileFilter
- java.nio.file.PathMatcher
- java.lang.reflect.InvocationHandler
- java.beans.PropertyChangeListener
- java.awt.event.ActionListener
- javax.swing.event.ChangeListener
Java8 新减少的函数接口在 java.util.function 包下，它蕴含了很多类，用来反对 Java 的 函数式编程，该包中的函数式接口有：
序号
接口 & 形容
1
BiConsumer<T,U>代表了一个承受两个输出参数的操作，并且不返回任何后果
2
BiFunction<T,U,R>代表了一个承受两个输出参数的办法，并且返回一个后果
3
BinaryOperator<T>代表了一个作用于于两个同类型操作符的操作，并且返回了操作符同类型的后果
4
BiPredicate<T,U>代表了一个两个参数的 boolean 值办法
5
BooleanSupplier代表了 boolean 值后果的提供方
6
Consumer<T>代表了承受一个输出参数并且无返回的操作
7
DoubleBinaryOperator代表了作用于两个 double 值操作符的操作，并且返回了一个 double 值的后果。
8
DoubleConsumer代表一个承受 double 值参数的操作，并且不返回后果。
9
DoubleFunction<R>代表承受一个 double 值参数的办法，并且返回后果
10
DoublePredicate代表一个领有 double 值参数的 boolean 值办法
11
DoubleSupplier代表一个 double 值构造的提供方
12
DoubleToIntFunction承受一个 double 类型输出，返回一个 int 类型后果。
13
DoubleToLongFunction承受一个 double 类型输出，返回一个 long 类型后果
14
DoubleUnaryOperator承受一个参数同为类型 double, 返回值类型也为 double。
15
Function<T,R>承受一个输出参数，返回一个后果。
16
IntBinaryOperator承受两个参数同为类型 int, 返回值类型也为 int。
17
IntConsumer承受一个 int 类型的输出参数，无返回值。
18
IntFunction<R>承受一个 int 类型输出参数，返回一个后果。
19
IntPredicate：承受一个 int 输出参数，返回一个布尔值的后果。
20
IntSupplier无参数，返回一个 int 类型后果。
21
IntToDoubleFunction承受一个 int 类型输出，返回一个 double 类型后果。
22
IntToLongFunction承受一个 int 类型输出，返回一个 long 类型后果。
23
IntUnaryOperator承受一个参数同为类型 int, 返回值类型也为 int。
24
LongBinaryOperator承受两个参数同为类型 long, 返回值类型也为 long。
25
LongConsumer承受一个 long 类型的输出参数，无返回值。
26
LongFunction<R>承受一个 long 类型输出参数，返回一个后果。
27
LongPredicate R 承受一个 long 输出参数，返回一个布尔值类型后果。
28
LongSupplier无参数，返回一个后果 long 类型的值。
29
LongToDoubleFunction承受一个 long 类型输出，返回一个 double 类型后果。
30
LongToIntFunction承受一个 long 类型输出，返回一个 int 类型后果。
31
LongUnaryOperator承受一个参数同为类型 long, 返回值类型也为 long。
32
ObjDoubleConsumer<T>承受一个 object 类型和一个 double 类型的输出参数，无返回值。
33
ObjIntConsumer<T>承受一个 object 类型和一个 int 类型的输出参数，无返回值。
34
ObjLongConsumer<T>承受一个 object 类型和一个 long 类型的输出参数，无返回值。
35
Predicate<T>承受一个输出参数，返回一个布尔值后果。
36
Supplier<T>无参数，返回一个后果。
37
ToDoubleBiFunction<T,U>承受两个输出参数，返回一个 double 类型后果
38
ToDoubleFunction<T>承受一个输出参数，返回一个 double 类型后果
39
ToIntBiFunction<T,U>承受两个输出参数，返回一个 int 类型后果。
40
ToIntFunction<T>承受一个输出参数，返回一个 int 类型后果。
41
ToLongBiFunction<T,U>承受两个输出参数，返回一个 long 类型后果。
42
ToLongFunction<T>承受一个输出参数，返回一个 long 类型后果。
43
UnaryOperator<T>承受一个参数为类型 T, 返回值类型也为 T。
用手指在上面向左（右）滑动，能够看残缺。
对于 Java8 中提供的这么多函数式接口，开发中罕用的函数式接口有三个:Predicate,Consumer,Function。
3.2、函数式接口实例
3.2.1、Predicate
java.util.function.Predicate<T> 接口定义了一个名叫 test 的形象办法，它承受泛型 T 对象，并返回一个 boolean。在须要示意一个波及类型 T 的布尔表达式时，能够应用这个接口, 通常称为断言性接口。
应用 Predicate 接口实现字符串判空操作
@FunctionalInterface
public interface Predicate<T> {
/**
- Evaluates this predicate on the given argument.
*
- @param t the input argument
- @return {@code true} if the input argument matches the predicate,
- otherwise {@code false}
*/
boolean test(T t);
…
}
public static void main(String[] args) {
/**
- 借助 Lambda 表达式实现 Predicate test 办法
*/
Predicate<String> p01=(str)->str.isEmpty()||str.trim().isEmpty();
/**
- 测试传入的字符串是否为空
*/
System.out.println(p01.test(“”));
System.out.println(p01.test(” “));
System.out.println(p01.test(“admin”));
}
测试后果:
3.2.2、Consumer
java.util.function.Consumer<T> 接口定义了一个名叫 accept 的形象办法, 它承受泛型 T，没有返回值(void)。如果须要拜访类型 T 的对象，并对其执行某些操作，能够应用这个接口, 通常称为消费性接口。
应用 Consumer 实现汇合遍历操作
@FunctionalInterface
public interface Consumer<T> {
/**
- Performs this operation on the given argument.
*
- @param t the input argument
*/
void accept(T t);
…
}
/**
- 借助 Lambda 表达式实现 Consumer accept 办法
*/
Consumer<Collection> c01 = (collection) -> {
if (null != collection && collection.size() > 0) {
for (Object c : collection) {
System.out.println(c);
}
}
};
List<String> list = new ArrayList<String>();
list.add(“ 诸葛亮 ”);
list.add(“ 曹操 ”);
list.add(“ 关羽 ”);
// 遍历 list 输入元素内容到控制台
c01.accept(list);
3.2.3、Function
java.util.function.Function<T, R> 接口定义了一个叫作 apply 的办法，它承受一个泛型 T 的对象，并返回一个泛型 R 的对象。如果须要定义一个 Lambda，将输出的信息映射到输入，能够应用这个接口(比方提取苹果的分量，或把字符串映射为它的长度), 通常称为功能性接口。
应用 Function 实现用户明码 Base64 加密操作
@FunctionalInterface
public interface Function<T, R> {
/**
- Applies this function to the given argument.
*
- @param t the function argument
- @return the function result
*/
R apply(T t);
}
// 实现用户明码 Base64 加密操作
Function<String,String> f01=(password)->Base64.getEncoder().encodeToString(password.getBytes());
// 输入加密后的字符串
System.out.println(f01.apply(“123456”));
加密后后果如下:
3.2.4、Supplier
java.util.function.Supplier<T> 接口定义了一个 get 的形象办法，它没有参数，返回一个泛型 T 的对象，这相似于一个工厂办法, 通常称为功能性接口。
应用 Supplier 实现 SessionFactory 创立
@FunctionalInterface
public interface Supplier<T> {
/**
- Gets a result.
*
- @return a result
*/
T get();
}
/**
- 产生一个 session 工厂对象
*/
Supplier<SessionFactory> s = () -> {
return new SessionFactory();
};
s.get().info();
