什么时候能够应用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

LongPredicateR承受一个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();