java 函数式接口 Functional Interface
1、函数式接口
1.1 定义
有且只有一个抽象方法的接口被称为函数式接口，函数式接口适用于函数式编程的场景，Lambda就是Java中函数式编程的体现，可以使用Lambda表达式创建一个函数式接口的对象，一定要确保接口中有且只有一个抽象方法，这样Lambda才能顺利的进行推导。
1.2 格式
修饰符 interface 接口名称 {
public abstract 返回值类型 方法名称(可选参数信息);
// 其他非抽象方法内容
}
由于接口当中抽象方法的 public abstract 是可以省略的，所以定义一个函数式接口很简单：
public interface MyFunctionalInterface {
void method();
}
1.3 @FunctionalInterface注解
与@Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解： @FunctionalInterface 。
该注解可用于一个接口的定义上,一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。需要注意的是，即使不使用该注解，只要满足函数式接口的定义，这仍然是一个函数式接口，也就是说函数式接口不以注解的存在而存在。
@FunctionalInterface
public interface MyFunctionalInterface {
void method();
}
1.4 自定义函数式接口
对于刚刚定义好的 MyFunctionalInterface 函数式接口，典型使用场景就是作为方法的参数：
public class Demo01 {
// 使用自定义的函数接口作为方法参数
private static void doSomething(MyFunctionalInterface mfi){
mfi.method(); // 调用自定义的函数式接口方法
}
public static void main(String[] args) {
// 调用使用函数式接口的方法
doSomething(()->{
System.out.println("自定义函数式接口的实现！");
});
}
}
2、常用的函数式接口
JDK提供了大量常用的函数式接口以丰富Lambda的典型使用场景，在jdk8中，引入了一个新的包java.util.function, 可以使java 8 的函数式编程变得更加简便。这个package中的接口大致分为了以下四类：
- Function: 接收参数，并返回结果，主要方法
R apply(T t) - Consumer: 接收参数，无返回结果, 主要方法为
void accept(T t) - Supplier: 不接收参数，但返回结构，主要方法为
T get() - Predicate: 接收参数，返回boolean值，主要方法为
boolean test(T t)
2.1 Supplier接口
java.util.function.Supplier<T> 接口仅包含一个无参的方法： T get()。用来获取一个泛型参数指定类型的对象数据。由于这是一个函数式接口，这也就意味着对应的Lambda表达式需要“对外提供”一个符合泛型类型的对象数据。
supplier<T>接口被称为生产型接口，指定借口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据
public class Test {
//定义一个方法，方法的参数传递Supplier<T>接口，泛型执行String，get方法返回一个String
private static String getString(Supplier<String> sup){
return sup.get();
}
public static void main(String[] args) {
String str1 = "Hello";
String str2 = "World";
System.out.println(getString(()->str1+str2));
}
}
练习：求数组的最大值
public class Test {
// 定义一个方法，方法的参数传递Supplier，泛型使用Integer
private static Integer getMax(Supplier<Integer> sup) {
return sup.get();
}
public static void main(String[] args) {
int[] arr = {6, 3, 96, 56, 84, 75, 26, 13};
// 调用getMax方法，参数传递Lambda
int max = getMax(() -> {
// 计算数组的最大值
int m = arr[0];
for (int i : arr) {
if (i > m) {
m = i;
}
}
return m;
});
System.out.println(max);
}
}
2.2 Consumer接口
java.util.function.Consumer<T> 接口则正好与Supplier接口相反，它不是生产一个数据，而是消费一个数据，其数据类型由泛型决定。
抽象方法：accept
Consumer 接口中包含抽象方法 void accept(T t)，意为消费一个指定泛型的数据。
Consumer接口是一个消费型的接口，泛型执行什么类型，就可以使用accept方法消费什么类型的数据，至于怎么消费，需要自定义输出、计算
基本使用如下：
public class Test {
private static void consumeString(Consumer<String> consumer) {
consumer.accept("Hello");
}
public static void main(String[] args) {
consumeString(s -> System.out.println(s));
}
}
默认方法：andThen
如果一个方法的参数和返回值全都是 Consumer 类型，那么就可以实现效果：消费数据的时候，首先做一个操作，然后再做一个操作，实现组合。而这个方法就是 Consumer 接口中的default方法 andThen 。下面是JDK的源代码：
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> { accept(t); after.accept(t); };
}
备注： java.util.Objects 的 requireNonNull 静态方法将会在参数为null时主动抛出 NullPointerException 异常。这省去了重复编写if语句和抛出空指针异常的麻烦。
要想实现组合，需要两个或多个Lambda表达式即可，而 andThen 的语义正是“一步接一步”操作。例如两个步骤组合的情况：
public class Test {
private static void consumeString(Consumer<String> c1, Consumer<String> c2) {
c1.andThen(c2).accept("Hello");
}
public static void main(String[] args) {
consumeString(
s -> System.out.println(s.toUpperCase(Locale.ROOT)),
s -> System.out.println(s.toLowerCase(Locale.ROOT)));
}
}
练习：格式化打印信息
字符串数组当中存有多条信息，请按照格式“ 姓名：XX。性别：XX。 ”的格式将信息打印出来。要求将打印姓名的动作作为第一个 Consumer 接口的Lambda实例，将打印性别的动作作为第二个 Consumer 接口的Lambda实例，将两个 Consumer 接口按照顺序“拼接”到一起。
public class Test {
public static void main(String[] args) {
String[] arr = {"张三,男", "李四,男", "小翠,女", "王二,男"};
consumeString(
s -> {
System.out.print("姓名:" +
s.substring(0, s.indexOf(",")));
},
s -> {
System.out.println(",性别:" +
s.substring(s.indexOf(",") + 1));
},
arr);
}
private static void consumeString(Consumer<String> c1,
Consumer<String> c2,
String[] arr) {
for (String s : arr) {
c1.andThen(c2).accept(s);
}
}
}
2.3 Predicate接口
有时候我们需要对某种类型的数据进行判断，从而得到一个boolean值结果。这时可以使用 java.util.function.Predicate<T> 接口。
抽象方法：test
Predicate 接口中包含一个抽象方法： boolean test(T t)。用于条件判断的场景：
public class Test {
private static void method(Predicate<String> pre) {
boolean test = pre.test("HelloWorld");
System.out.println("该字符串是否很长：" + test);
}
public static void main(String[] args) {
method(s -> {
return s.length() > 5;
});
}
}
默认方法：逻辑与 && and
将两个 Predicate 条件使用“与”逻辑连接起来实现“并且”的效果时，可以使用default方法 and 。其JDK源码为：
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
例如
public class Test{
public static void main(String[] args) {
method(s -> {
return s.contains("H");
}, s -> {
return s.contains("W");
});
}
private static void method(Predicate<String> pre1, Predicate<String> pre2) {
// boolean test = pre1.test("HelloWorld") && pre2.test("HelloWorld");
boolean test = pre1.and(pre2).test("HelloWorld");
System.out.println("该字符串是否满足要求：" + test);
}
}
默认方法：逻辑与 || or
实现逻辑中的或，源码为：
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
例如：
public class Test {
private static void method(Predicate<String> pre1, Predicate<String> pre2) {
boolean test = pre1.or(pre2).test("hello world");
System.out.println("该字符串是否满足要求：" + test);
}
public static void main(String[] args) {
method(s -> s.contains("H"), s -> s.contains("W"));
}
}
默认方法：取反 ！not
取反操作的源码为：
default Predicate<T> negate() {
return (t) -> !test(t);
}
例如：
public class Test {
private static void method(Predicate<String> pre) {
boolean test = pre.negate().test("HelloWorld");
System.out.println("字符串长度是否大于3:" + test);
}
public static void main(String[] args) {
method(s->s.length()>3);
}
}
练习：集合信息筛选
筛选出姓名长度大于2且年龄大于13的学生信息
class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Test {
private static List<Student> getList(Predicate<Student> pre1, Predicate<Student> pre2, List<Student> arr) {
List<Student> list = new ArrayList<>();
for (Student s : arr) {
boolean test = pre1.and(pre2).test(s);
if (test) {
list.add(s);
}
}
return list;
}
public static void main(String[] args) {
List<Student> students = new ArrayList<>();
students.add(new Student("ming", 13));
students.add(new Student("xu", 10));
students.add(new Student("lin", 9));
students.add(new Student("mei", 28));
List<Student> sList = getList(student -> student.getName().length()>=3, student->student.getAge()>12,students);
System.out.println(sList);
}
}
2.4 Function接口
java.util.function.Function<T, R> 接口用来根据一个类型的数据得到另一个类型的数据，前者称为前置条件，后者称为后置条件
抽象方法：apply
Function 接口中最主要的抽象方法为： R apply(T t) ，根据类型T的参数获取类型R的结果。
使用的场景例如：将 String 类型转换为 Integer 类型
public class Test {
private static void method(Function<String, Integer> fun) {
Integer a = fun.apply("345");
System.out.println(a);
}
public static void main(String[] args) {
method(s -> Integer.parseInt(s) + 321);
}
}
默认方法：andThen
Function 接口中有一个默认的 andThen 方法，用来进行组合操作。源码如下：
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
例如：
public class Test {
private static void change(String s, Function<String, Integer>fun1, Function<Integer, String>fun2){
System.out.println(fun1.andThen(fun2).apply(s));
}
public static void main(String[] args) {
String s = "123";
change(s,(String str)->{
return Integer.parseInt(str)+10;
},(Integer i)->{
return i+"";
});
// 优化lambda
change(s,str-> Integer.parseInt(str)+10,i->i+"");
}
}
请注意，Function的前置条件泛型和后置条件泛型可以相同
练习：自定义函数模型拼接
题目
请使用 Function 进行函数模型的拼接，按照顺序需要执行的多个函数操作为：
String str = “ming,20”;
将字符串截取数字年龄部分，得到字符串
将上一步的字符串转换成为int类型的数字
将上一步的int数字加8，得到结果int数字
public class Test {
private static void method(String str, Function<String, String> fun1,
Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
Integer res = fun1.andThen(fun2.andThen(fun3)).apply(str);
System.out.println(res);
}
public static void main(String[] args) {
String str = "赵丽颖,20";
method(str,
s -> s.split(",")[1],
s -> Integer.parseInt(s),
i -> i + 10);
}
}
3、写在最后
JDK 1.8 之前已有的函数式接口:
- java.lang.Runnable
- java.util.concurrent.Callable
- java.security.PrivilegedAction
- java.util.Comparator
- java.io.FileFilter
- java.nio.file.PathMatcher
- java.lang.reflect.InvocationHandler
- java.beans.PropertyChangeListener
- java.awt.event.ActionListener
- javax.swing.event.ChangeListener
JDK 1.8 新增加的函数接口：
- java.util.function
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。 |
