函数式接口详解（Java）
1.1 函数式接口概述
函数式接口：有且仅有一个抽象方法的接口
Java中函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口
只有确保接口中仅有一个抽象方法，Java中的Lambda才能顺利地进行推导
如何检测一个接口是不是函数式接口呢？
- @Functionallnterface
- 放在 接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
注意：
- 我们自己定义函数式接口的时候，@Functionallnterface是可以选的，就算我们不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解
1.2 函数式接口作为方法的参数
需求
- 定义一个类（RunnableDemo），在类中提供两个方法
- 一个方法是：startThread(Runnable r) 方法参数Runnabler是一个函数式接口
- 一个方法是主方法，在主方法中调用startThread方法
如果方法的参数是一个函数式接口，我们可以用Lambda表达式作为参数传递
- startThread(()->System.out.println(Thread.currentThread().getName()+“线程启动了”));
public class RunnableDemo {
public static void main(String[] args) {
startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));
}
private static void startThread(Runnable r){
new Thread(r).start();
}
}
1.3 函数式接口作为方法的返回值
需求
- 定义一个类（ComparatorDemo），在类中提供两个方法
- 一个方法是：Comparator< String > getComparator() 方法返回值Comparator是一个函数式接口
- 一个方法是主方法，在主方法中调用getComparator方法
如果一个方法的返回值是一个函数式接口，我们可以把一个Lambda表达式作为结果返回
-
private static Comparator<String> getComparator() { //Lambda表达式写法 return (s1, s2) -> s1.length() - s2.length(); }
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class ComparatorDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("cccc");
list.add("aa");
list.add("b");
list.add("ddd");
System.out.println("排序前" + list);
Collections.sort(list, getComparator());
System.out.println("排序后" + list);
}
//如果一个方法的返回值是一个函数式接口，我们可以把一个Lambda表达式作为结果返回
private static Comparator<String> getComparator() {
//使用匿名内部类实现
// return new Comparator() {
// @Override
// public int compare(String s1, String s2) {
// return s1.length()-s2.length();
// }
// };
//Lambda表达式写法
return (s1, s2) -> s1.length() - s2.length();
}
}
2.1 常用的函数式接口
Java 8在java.util.function包下预定义了大量的函数式接口供我们使用
我们重点学习下面4个接口
- Supplier接口
- Consumer接口
- Predicate接口
- Function接口
2.1.1 Supplier接口
Supplier< T >：包含一个无参的方法
- T get()：获得结果
- 该方法不需要参数，他会按照某种实现逻辑（由Lambda表达式实现）返回一个数据
- Supplier< T >接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据供我们使用
import java.util.function.Supplier;
public class SupplierDemo {
public static void main(String[] args) {
String s = getString(()->"张三");
int i = getInteger(()->18);
System.out.println(s+","+i);
}
//定义一个方法，返回一个字符串数据
private static String getString(Supplier<String> sup){
return sup.get();
}
//定义一个方法，返回一个整数数据
private static Integer getInteger(Supplier<Integer> sup){
return sup.get();
}
}
练习：
- 定义一个类（SupplierTest），在类中提供两个方法
- 一个方法是：int getMax(Supplier< Integer > sup) 用于返回一个int数组中的最大值
- 一个方法是主方法，在主方法中调用getMax方法
import java.util.function.Supplier;
public class SupplierTest {
public static void main(String[] args) {
int[] i = {3,75,32,76,98,42};
int maxValue = getMax(()->{
int max = i[0];
for (int j = 1; j < i.length; j++) {
if(i[j]>max){
max = i[j];
}
}
return max;
});
System.out.println(maxValue);
}
private static Integer getMax(Supplier<Integer> sup){
return sup.get();
}
}
2.1.2 Consumer接口
Consumer< T >：包含两个方法
- void accept(T t)：对给定的参数执行此操作
- default Consumer < T > andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作
- Consumer< T >接口也被称为消费型接口，它消费的数据类型由泛型指定
import java.util.function.Consumer;
public class ConsumerDemo {
public static void main(String[] args) {
operatorString("张三", (s) -> System.out.println(s));
operatorString("张三", (s) -> System.out.println(s), (s)-> System.out.println(new StringBuilder(s).reverse().toString()));
}
//定义一个方法，消费一个字符串数据
private static void operatorString(String name, Consumer<String> con) {
con.accept(name);
}
//定义一个方法，用不同的方式消费同一个字符串两次
private static void operatorString(String name, Consumer<String> con1,Consumer<String> con2) {
// con1.accept(name);
// con2.accept(name);
//返回一个组合的Consumer
con1.andThen(con2).accept(name);
}
}
练习：
- String[] strArray = {“张三,30”, “李四,21”, “王五,18”};
- 字符串数组中有多条信息，请按照格式：
- 把打印姓名的动作作为第一个Consumer接口的Lambda实例
- 把打印年龄的动作作为第二个Consumer接口的Lambda实例
- 将两个Consumer接口按照顺序组合到一起使用
import java.util.function.Consumer;
public class ConsumerTest {
public static void main(String[] args) {
String[] strArray = {"张三,30", "李四,21", "王五,18"};
printInfo(strArray,
s1 -> System.out.print("姓名：" + s1.split(",")[0] + ","),
s2 -> System.out.println("年龄：" + s2.split(",")[1]));
}
private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
for (String str :
strArray) {
con1.andThen(con2).accept(str);
}
}
}
2.1.3 Predicate接口
Predicate< T >：常用的四个方法
- boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值
- default Predicate< T > negate()：返回一个逻辑的否定，对应逻辑非
- default Predicate< T > and()：返回一个组合判断，对应短路与
- default Predicate< T > or()：返回一个组合判断，对应短路或
- isEqual()：测试两个参数是否相等
- Predicate< T >：接口通常用于判断参数是否满足指定的条件
test(T t) 、negate()
import java.util.function.Predicate;
public class ConsumerTest {
public static void main(String[] args) {
boolean string = chenkString("张三", s -> s.equals("张三"));
System.out.println(string);
boolean hello = chenkString("hello", s -> s.length() > 8, s -> s.length() < 18);
System.out.println(hello);
}
//判定给定的字符串是否满足要求
// private static boolean chenkString(String s, Predicate pre){
// return pre.test(s);
// }
private static boolean chenkString(String s, Predicate<String> pre){
return pre.negate().test(s);
}
// private static boolean chenkString(String s, Predicate pre, Predicate pre1){
// return pre.and(pre1).test(s);
// }
private static boolean chenkString(String s, Predicate<String> pre, Predicate<String> pre1){
return pre.or(pre1).test(s);
}
}
练习：
- String[] strArray = {“张三,30”, “李四,21”, “王五,18”};
- 字符串数组中由多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合Arraylist中，并遍历ArrayList集合
- 同时满足如下小球：姓名长度大于1，年龄大于20
- 分析
- 有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
- 必须同时满足两个条件，所以可以使用and方法连接两个判断条件
import java.util.ArrayList;
import java.util.function.Predicate;
public class ConsumerTest {
public static void main(String[] args) {
String[] strArray = {
"张三,30", "李四,21", "王五,18"
};
ArrayList<String> arrayList = myFilter(strArray,
s -> s.split(",")[0].length() > 1,
s -> Integer.parseInt(s.split(",")[1]) > 20
);
for (String array : arrayList) {
System.out.println(array);
}
}
//通过Predicate接口的拼装将符合要求的字符串筛选到集合Arraylist中
private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
//定义一个集合
ArrayList<String> array = new ArrayList<>();
//遍历数组
for (String str : strArray) {
if (pre1.and(pre2).test(str)) {
array.add(str);
}
}
return array;
}
}
2.1.4 Function接口
Runction
- R apply(T t)：将此函数应用于给定的参数
- default< V >：Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
- Function
import java.util.function.Function;
public class ConsumerTest {
public static void main(String[] args) {
convert("18", s -> Integer.parseInt(s));
convert(20, integer -> String.valueOf(integer + 18));
convert("245", s -> Integer.parseInt(s), integer -> String.valueOf(integer + 18));
}
//定义一个方法，把一个字符串转换成int类型，在控制台输出
private static void convert(String s, Function<String, Integer> fun) {
int i = fun.apply(s);
System.out.println(i);
}
//定义一个方法，把int类型数据加上一个整数之后，转换为字符串在控制台输出
private static void convert(int i, Function<Integer, String> fun) {
String s = fun.apply(i);
System.out.println(s);
}
//定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数后，转换成字符串在控制台输出
private static void convert(String s, Function<String, Integer> fun1, Function<Integer, String> fun2) {
String s1 = fun2.apply(fun1.apply(s));
System.out.println(s1);
}
}