1、函数式接口概述
函数式接口：有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导
如何检测一个接口是不是函数式接口？
-
@FunctionalInterface
- 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
注意
- 我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算不写这个注解，只要保证满足函数式接口定义的条件，也同样是函数式接口。但是，建议加上该注解
2、函数式接口作为方法的参数
需求
- 定义一个类(RunnableDemo)，在类中提供两个方法
- 一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
- 一个方法是主方法，在主方法中调用startThread方法
如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递
- startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动"));
package FunctionInterface02;
/*
定义一个类(RunnableDemo)，在类中提供两个方法
一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
一个方法是主方法，在主方法中调用startThread方法
*/
public class RunnableDemo {
public static void main(String[] args) {
//在主方法中调用startThread方法
//匿名内部类的方式
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程启动");
}
});
//Lambda表达式
startThread(() -> {
System.out.println(Thread.currentThread().getName() + "线程启动");
});
startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动"));
}
private static void startThread(Runnable r) {
// Thread t = new Thread(r);
// t.start();
new Thread(r).start();
}
}
3、函数式接口作为方法的返回值
需求：
- 定义一个类(ComparatorDemo)，在类中提供两个方法
- 一个方法是：Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口
- 一个方法是主方法，在主方法中调用getComparator方法
如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回
private static Comparator<String> getComparator() {
return (s1, s2) -> s1.length() - s2.length();
}
package FunctionInterface03;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
/*
定义一个类(ComparatorDemo)，在类中提供两个方法
一个方法是：Comparator<String> getComparator() 方法返回值Comparator是一个函数式接口
一个方法是主方法，在主方法中调用getComparator方法
*/
public class ComparatorDemo {
public static void main(String[] args) {
//构造使用的场景
//定义集合，存储字符串元素
ArrayList<String> array = new ArrayList<String>();
array.add("cccc");
array.add("aa");
array.add("b");
array.add("ddd");
System.out.println("排序前：" + array);
Collections.sort(array);
System.out.println("排序后：" + array);
Collections.sort(array, getComparator());
System.out.println("排序后：" + array);
}
private static Comparator<String> getComparator() {
//使用匿名内部类的方式实现
// Comparator<String> comp = new Comparator<String>() {
// @Override
// public int compare(String s1, String s2) {
// return s1.length() - s2.length();
// }
// };
// return comp;
// return new Comparator<String>() {
// @Override
// public int compare(String s1, String s2) {
// return s1.length() - s2.length();
// }
// };
//Lambda表达式
// return (String s1, String s2) -> {
// return s1.length() - s2.length();
// };
return (s1, s2) -> s1.length() - s2.length();
}
}
4、常用的函数式接口
Java8在java.util.function包下预定义了大量的函数式接口供我们使用
- Supplier接口
- Consumer接口
- Predicate接口
- Function接口
5、Supplier接口
Supplier<T>：包含一个无参的方法
- T get()：获得结果
- 该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
- Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用
package FunctionInterface03;
import java.util.function.Supplier;
/*
Supplier<T>：包含一个无参的方法
T get()：获得结果
该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据
Supplier<T>接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用
*/
public class RunnableDemo {
public static void main(String[] args) {
// String s = getString(() -> {
// return "刘亦菲";
// });
String s = getString(() -> "刘亦菲");
System.out.println(s);
// int i = getInt(() -> {
// return 5;
// });
int i = getInt(() -> 5);
System.out.println(i);
}
//定义一个方法返回一个整数数据
private static int getInt(Supplier<Integer> i) {
return i.get();
}
//定义一个方法返回一个字符串数据
private static String getString(Supplier<String> sup) {
return sup.get();
}
}
练习：获取数组中最大值
- 定义一个类(SupplierTest)，在类中提供两个方法
- 一个方法是：int getMax(Supplier<Integer> sup) 用于返回一个int数组中的最大值
- 一个方法是主方法，在主方法中调用getMax方法
package FunctionInterface03;
import java.util.function.Supplier;
/*
定义一个类(SupplierTest)，在类中提供两个方法
一个方法是：int getMax(Supplier<Integer> sup) 用于返回一个int数组中的最大值
一个方法是主方法，在主方法中调用getMax方法
*/
public class SupplierTest {
public static void main(String[] args) {
//定义一个int数组
int[] arr = {25, 36, 89, 65, 12, 34, 53};
int maxValue = getMax(() -> {
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
});
System.out.println(maxValue);
}
private static int getMax(Supplier<Integer> sup) {
return sup.get();
}
}
6、Consumer接口
Consumer<T>：包含两个方法
- void accept(T t)：对给定的参数执行此操作
- default Consumer<T> andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作
- Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
package FunctionInterface04;
import java.util.function.Consumer;
/*
Consumer<T>：包含两个方法
void accept(T t)：对给定的参数执行此操作
default Consumer<T> andThen(Consumer after)：返回一个组合的Consumer，依次执行此操作，然后执行after操作
Consumer<T>接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
*/
public class ConsumerDemo {
public static void main(String[] args) {
operatorString("刘亦菲", (String s) -> {
System.out.println(s);
});
operatorString("刘亦菲", s -> System.out.println(s));
operatorString("刘亦菲", System.out::println);
operatorString("刘亦菲", (String s) -> {
System.out.println(new StringBuilder(s).reverse().toString());
});
operatorString("刘亦菲", s -> System.out.println(new StringBuilder(s).reverse().toString()));
System.out.println("--------------------");
operatorString("刘亦菲", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));
}
//定义一个方法，用不同的方式消费同一个字符串数据两次
private static void operatorString(String name, Consumer<String> con1, Consumer<String> con2) {
// con1.accept(name);
// con2.accept(name);
con1.andThen(con2).accept(name);
}
//定义一个方法，消费一个字符串数据
private static void operatorString(String name, Consumer<String> con) {
con.accept(name);
}
}
练习
- String[] strArray = {"刘亦菲,36","杨幂,30","王祖贤，40”}；
- 字符串数组中有多条信息，请按照格式：“姓名：XX，年龄：XX”的格式打印信息
- 要求：
- 把打印姓名的动作作为第一个Consumer接口的Lambda实例
- 把打印年龄的动作作为第二个Consumer接口的Lambda实例
- 将两个Consumer接口按照顺序组合到一起使用
package FunctionInterface04;
import java.util.function.Consumer;
/*
String[] strArray = {"刘亦菲,36","杨幂,30","王祖贤，40”}；
字符串数组中有多条信息，请按照格式：“姓名：XX，年龄：XX”的格式打印信息
要求：
把打印姓名的动作作为第一个Consumer接口的Lambda实例
把打印年龄的动作作为第二个Consumer接口的Lambda实例
将两个Consumer接口按照顺序组合到一起使用
*/
public class ConsumerTest {
public static void main(String[] args) {
String[] strArray = {"刘亦菲，36", "杨幂，30", "王祖贤，40" };
printInfo(strArray, (String str) -> {
String name = str.split("，")[0];
System.out.print("姓名：" + name);
}, (String str) -> {
int age = Integer.parseInt(str.split("，")[1]);
System.out.println("，年龄：" + age);
});
printInfo(strArray, str -> System.out.print("姓名：" + str.split("，")[0]),
str -> System.out.println("年龄：" + Integer.parseInt(str.split("，")[1])));
}
private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
for (String str : strArray) {
con1.andThen(con2).accept(str);
}
}
}
7、Predicate接口
Predicate<T>：常用的四个方法
- boolean test(T t)：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
- default Predicate<T> negate()：返回一个逻辑地否定，对应逻辑非
- default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与
- default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或
- Predicate<T>接口通常用于判断参数是否满足指定的条件
package FunctionInterface05;
import java.util.function.Predicate;
/*
Predicate<T>：常用的四个方法
boolean test(T t)：对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
default Predicate<T> negate()：返回一个逻辑地否定，对应逻辑非
default Predicate<T> and(Predicate other)：返回一个组合判断，对应短路与
default Predicate<T> or(Predicate other)：返回一个组合判断，对应短路或
Predicate<T>接口通常用于判断参数是否满足指定的条件
*/
public class PredicateDemo01 {
public static void main(String[] args) {
// boolean b1 = checkString("hello", (String s) -> {
// return s.length() > 8;
// });
boolean b1 = checkString("hello", s -> s.length() > 8);
System.out.println(b1);
boolean b2 = checkString("helloworld", s -> s.length() > 8);
System.out.println(b2);
boolean b3 = checkString("hello", s -> s.length() > 8, s -> s.length() < 15);
System.out.println(b3);
boolean b4 = checkString("helloworld", s -> s.length() > 8, s -> s.length() < 15);
System.out.println(b4);
}
//同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
// boolean b1 = pre1.test(s);
// boolean b2 = pre2.test(s);
// boolean b = b1 && b2;
// return b;
// return pre1.and(pre2).test(s);
return pre1.or(pre2).test(s);
}
//判断给定的字符串是否满足要求
private static boolean checkString(String s, Predicate<String> pre) {
// return pre.test(s);
// return !pre.test(s);
return pre.negate().test(s);
}
}
练习：
- String[] strArray = {"林青霞,30","柳岩,34","张曼玉,35","杨幂,31","王祖贤，33"}；
- 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
- 同时满足如下要求：姓名长度大于2；年龄大于33
- 分析
- 有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
- 必须同时满足两个条件，所以可以使用and方法连接两个判断条件
package FunctionInterface05;
import java.util.ArrayList;
import java.util.function.Predicate;
/*
String[] strArray = {"林青霞,30","柳岩,34","张曼玉,35","杨幂,31","王祖贤，33"};
字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
同时满足如下要求：姓名长度大于2；年龄大于33
分析
有两个判断条件，所以需要使用两个Predicate接口，对条件进行判断
必须同时满足两个条件，所以可以使用and方法连接两个判断条件
*/
public class PredicateTest {
public static void main(String[] args) {
String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "杨幂,31", "王祖贤,33"};
// ArrayList<String> array = myFilter(strArray, (String s) -> {
// return s.split(",")[0].length() > 2;
// }, (String s) -> {
// return Integer.parseInt(s.split(",")[1]) > 33;
// });
ArrayList<String> array = myFilter(strArray, s -> s.split(",")[0].length() > 2,
s -> Integer.parseInt(s.split(",")[1]) > 33);
for (String str : array) {
System.out.println(str);
}
}
//通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中
//返回一个ArrayList
private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
//定义一个集合
ArrayList<String> array = new ArrayList<String>();
//遍历数组
for (String str : strArray) {
if (pre1.and(pre2).test(str)) {
array.add(str);
}
}
return array;
}
}
8、Function接口
Function<T>：常用的两个方法
- R apply(T t)：将此函数应用于给定的参数
- default<V> Function andThen(Function after):返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
- Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值
package FunctionInterface06;
import java.util.function.Function;
/*
Function<T>：常用的两个方法
R apply(T t)：将此函数应用于给定的参数
default<V> Function andThen(Function after):返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值
*/
public class FunctionDemo {
public static void main(String[] args) {
// convert("100", (String s) -> {
// return Integer.parseInt(s);
// });
convert("100", s -> Integer.parseInt(s));
convert("100", Integer::parseInt);
// convert(100,(Integer i)->{
// return String.valueOf(i+566);
// });
convert(100, i -> String.valueOf(i + 566));
// convert("100", (String s) -> {
// return Integer.parseInt(s);
// }, (Integer i) -> {
// return String.valueOf(i + 566);
// });
convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
}
//定义一个方法，把一个字符串转换int类型，在控制台输出
private static void convert(String s, Function<String, Integer> fun) {
// Integer i = fun.apply(s);
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) {
// Integer i = fun1.apply(s);
// String ss = fun2.apply(i);
// System.out.println(ss);
String ss = fun1.andThen(fun2).apply(s);
System.out.println(ss);
}
}
练习：
- String s = "林青霞,30";
- 需求：
- 将字符串截取得到数字年龄部分
- 将上一步的年龄字符串转换成int类型的数据
- 将上一步的int类型数据加70，得到一个int结果，在控制台输出
- 请通过Function接口来实现函数拼接
package FunctionInterface06;
import java.util.function.Function;
/*
String s = "林青霞,30";
需求：
将字符串截取得到数字年龄部分
将上一步的年龄字符串转换成int类型的数据
将上一步的int类型数据加70，得到一个int结果，在控制台输出
请通过Function接口来实现函数拼接
*/
public class FunctionTest {
public static void main(String[] args) {
String s = "林青霞,30";
convert(s, (String ss) -> {
return s.split(",")[1];
}, (String ss) -> {
return Integer.parseInt(ss);
}, (Integer i) -> {
return i + 70;
});
//优化
convert(s, ss -> s.split(",")[1], ss -> Integer.parseInt(ss), i -> i + 70);
//优化
convert(s, ss -> s.split(",")[1], Integer::parseInt, i -> i + 70);
}
private static void convert(String s, Function<String, String> fun1, Function<String, Integer> fun2, Function<Integer, Integer> fun3) {
// Integer i = fun1.andThen(fun2).andThen(fun3).apply(s);
int i = fun1.andThen(fun2).andThen(fun3).apply(s);
System.out.println(i);
}
}
1757
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
