目录
1、函数式接口概述
有且仅有一个抽象方法的接口，通过在类上标注 @functionalInterface 注解进行检测。
该注解为可选，只要保证满足函数式接口定义的条件也照样是函数式接口，但是建议都加上该注解（规范）。
示例
@FunctionalInterface
public interface MyFunctionalInterface {
void show();
}
2、函数式接口作为方法的参数
示例
public class Test_01 {
public static void main(String[] args) {
// 匿名内部类方式
startRunable(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 线程启动");
}
});
// lambda方式
startRunable(() -> System.out.println(Thread.currentThread().getName() + " 线程启动"));
}
// Runnable类是一个函数式接口
public static void startRunable(Runnable r) {
new Thread(r).start();
}
}
Thread-0 线程启动
Thread-1 线程启动
3、函数式接口作为方法的返回值
示例： 按照字符串长度正序排序
public class Test_02 {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
list1.add("bbb");
list1.add("a");
list1.add("cc");
System.out.println("排序前 = " + list1);
Collections.sort(list1);
System.out.println("默认排序后 = " + list1);
ArrayList<String> list2 = new ArrayList<>();
list2.add("bbb");
list2.add("a");
list2.add("cc");
System.out.println("排序前 = " + list2);
Collections.sort(list2, getComparator());
System.out.println("自定义排序后 = " + list2);
}
// 按照字符串长度正序排序，将Comparator函数式接口作为返回值
// lambda方式
public static Comparator<String> getComparator() {
return (s1, s2) -> s1.length() - s2.length();
}
// 方法引用方式
public static Comparator<String> getComparator2() {
return Comparator.comparingInt(String::length);
}
// 匿名内部类方式
public static Comparator<String> getComparator3() {
return new Comparator<String>() {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
};
}
}
排序前 = [bbb, a, cc]
默认排序后 = [a, bbb, cc]
排序前 = [bbb, a, cc]
自定义排序后 = [a, cc, bbb]
4、常用函数式接口
Java 8 在 java.util.function 包下预定义了大量的函数式接口供我们使用，以下为四大核心函数式接口
| 接口 | 说明 |
|---|---|
| Supplier
|
生产型接口，接口中泛型指定什么类型，则 get 方法就生产该类型数据，T - 出参类型，没有入参 |
| Consumer
|
消费型接口，消费的数据其类型由泛型指定，T - 入参类型，没有出参 |
| Predicate
|
断言式接口，通常用于判断参数是否满足指定的条件，T - 入参类型，出参为 boolean 类型 |
| Function<T,R> | 函数式接口，通常用于对参数进行处理、转换（处理逻辑由 Lambda 表达式实现），然后返回一个新的值，T - 入参类型，R - 出参类型 |
4.1、Supplier 接口
| 方法 | 说明 |
|---|---|
| T get() | 该方法不需要参数，它会按照某种实现逻辑返回一个数据（由 Lambda 表达式实现） |
示例
public class Test_03 {
public static void main(String[] args) {
String name = getString(() -> "勋悟空");
System.out.println("name = " + name);
Integer age = getInteger(() -> 500);
System.out.println("age = " + age);
}
// 返回 String 类型数据
public static String getString(Supplier<String> sup) {
return sup.get();
}
// 返回 Integer 类型数据
public static Integer getInteger(Supplier<Integer> sup) {
return sup.get();
}
// 返回其它类型数据...
}
name = 勋悟空
age = 500
4.2、Consumer 接口
| 方法 | 说明 |
|---|---|
| void accept(T t) | 对给定的参数执行此操作 |
| default Consumer
|
依次执行此操作，然后执行 after 操作 |
示例
public class Test_05 {
public static void main(String[] args) {
// 打印该字符串，消费了一次
operatorString("勋悟空", System.out::println);
// 先打印该字符串，再获取该字符串的长度，消费了两次
operatorString("勋悟空", System.out::println, s -> System.out.println(s.length()));
}
// 方法1：消费一个字符串数据
public static void operatorString(String name, Consumer<String> con) {
con.accept(name);
}
// 方法2：对一个字符串数据连续消费两次
public static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
// con1.accept(name);
// con2.accept(name);
// 写法优化
con1.andThen(con2).accept(name);
}
}
勋悟空
勋悟空
3
4.3、Predicate 接口
| 方法 | 说明 |
|---|---|
| boolean test(T t) | 对给定的参数进行判断，返回一个布尔值（判断逻辑由 Lambda 表达式实现） |
| default Predicate
|
返回一个逻辑的否定，对应 逻辑非（ ! ） |
| default Predicate
|
返回一个组合判断，对应 短路与（&&） |
| default Predicate
|
返回一个组合判断，对应 短路或（||） |
示例
public class Test_07 {
public static void main(String[] args) {
// 方法1
boolean b1 = checkString1("hello", s -> s.length() > 6); // false
boolean b2 = checkString1("hello", s -> s.length() < 6); // true
// 方法2
boolean b3 = checkString2("hello", s -> s.length() > 6); // true
boolean b4 = checkString2("hello", s -> s.length() < 6); // false
// 方法3
boolean b5 = checkString3("hello", s -> s.length() > 6, s -> s.length() < 6); // false
boolean b6 = checkString3("hello", s -> s.length() > 3, s -> s.length() < 6); // true
// 方法4
boolean b7 = checkString4("hello", s -> s.length() > 6, s -> s.length() < 6); // true
boolean b8 = checkString4("hello", s -> s.length() > 3, s -> s.length() < 6); // true
}
// 方法1：判断给定字符串是否满足要求
public static boolean checkString1(String s, Predicate<String> pre) {
return pre.test(s);
}
// 方法2：判断给定字符串是否满足要求（结果取反）
public static boolean checkString2(String s, Predicate<String> pre) {
return pre.negate().test(s);
}
// 方法3：对同一个字符串给出两个不同的判断条件，再把这两个结果做 短路与 运算，得出的结果做最终结果
public static boolean checkString3(String s, Predicate<String> pre1, Predicate<String> pre2) {
return pre1.and(pre2).test(s);
}
// 方法4：对同一个字符串给出两个不同的判断条件，再把这两个结果做 短路或 运算，得出的结果做最终结果
public static boolean checkString4(String s, Predicate<String> pre1, Predicate<String> pre2) {
return pre1.or(pre2).test(s);
}
}
b1 = false
b2 = true
--------
b3 = true
b4 = false
--------
b5 = false
b6 = true
--------
b7 = true
b8 = true
4.4、Function 接口
| 方法 | 说明 |
|---|---|
| R apply(T t) | 将此函数应用于给定的参数 |
| default
|
返回一个组合函数，首先将该函数应用于输入，然后将 after 函数应用于结果 |
示例
public class Test_09 {
public static void main(String[] args) {
// 方法1
convert("1", Integer::parseInt);
// 方法2
convert(1, i -> String.valueOf(i + 10));
// 方法3
convert("1", Integer::valueOf, s -> String.valueOf(s + 100));
}
// 方法1：将一个字符串转换为Integer类型并在控制台输出
public static void convert(String s, Function<String, Integer> fun) {
Integer i = fun.apply(s);
System.out.println("i = " + i);
}
// 方法2：将一个Integer类型数据加上一个整数之后，转换为字符串并在控制台输出
public static void convert(int i, Function<Integer, String> fun) {
String s = fun.apply(i);
System.out.println("s = " + s);
}
// 方法3：将一个字符串转换为Integer类型，把Integer类型数据加上一个整数之后，再转为字符串并在控制台输出
public static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
String ss = fun1.andThen(fun2).apply(s);
System.out.println("ss = " + ss);
}
}
i = 1
s = 11
ss = 101