函数式接口概述
概念：
有且仅有一个抽象方法的接口
如何检测一个接口是不是函数式接口？
- @FunctionalInterface
- 放在接口定义的上方：如果接口是函数式接口，编译通过；如果不是，编译失败
注意事项：
我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上该注解
函数式接口作为方法的参数
1 @FunctionalInterface
2 public interface Runnable {
3 void run();
4 }1 /*需求描述：
2 定义一个类(RunnableDemo)，在类中提供两个方法
3
4 一个方法是：startThread(Runnable r) 方法参数Runnable是一个函数式接口
5 一个方法是主方法，在主方法中调用startThread方法*/
6 public class RunnableDemo {
7 public static void main(String[] args) {
8 //在主方法中调用startThread方法
9
10 //方式一：匿名内部类
11 startThread(new Runnable() {
12 @Override
13 public void run() {
14 System.out.println(Thread.currentThread().getName() + "：线程启动了");
15 }
16 });
17
18 System.out.println("--------");
19
20 //方式二：Lambda表达式
21 startThread(() -> System.out.println(Thread.currentThread().getName() + "：线程启动了"));
22 }
23
24
25 public static void startThread(Runnable r) {
26 new Thread(r).start();
27 }
28 }
函数式接口作为方法的返回值
如果一个方法的返回值是一个函数式接口，可以把一个lambda表达式作为结果返回。
1 /*需求描述
2 定义一个类(ComparatorDemo)，在类中提供两个方法
3 一个方法是：Comparator getComparator() 方法返回值Comparator是一个函数式接口
4 一个方法是主方法，在主方法中调用getComparator方法*/
5 import java.util.ArrayList;
6 import java.util.Collections;
7 import java.util.Comparator;
8
9 public class ComparatorDemo {
10 public static void main(String[] args) {
11 //创建集合
12 ArrayList<String> arr=new ArrayList<>();
13 //添加元素
14 arr.add("aa");
15 arr.add("ssss");
16 arr.add("ddd");
17 arr.add("cccccc");
18
19 System.out.println("排序前："+arr);
20
21 // static <T> void sort(List<T> list, Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序。
22 Collections.sort(arr,getComparator());
23
24 System.out.println("排序后："+arr);
25 }
26
27 public static Comparator<String> getComparator(){
28 // 方式一：匿名内部类
29 // return new Comparator<String>() {
30 // @Override
31 // public int compare(String s1, String s2) {
32 // return s1.length()-s2.length();
33 // }
34 // };
35
36 // 方式二：Lambda表达式
37 return (s1,s2)->s1.length()-s2.length();
38 }
39 }
常用函数式接口之Supplier
Supplier接口:
Supplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用。
常用方法:
只有一个无参的方法
1 T get() 按照某种实现逻辑(由Lambda表达式实现)返回一个数据1 import java.util.function.Supplier;
2
3 public class SupplierDemo {
4 public static void main(String[] args) {
5 Integer i = getInteger(() -> 10086);
6 System.out.println(i);
7
8 String s = getString(() -> "令狐冲");
9 System.out.println(s);
10 }
11
12 //定义一个方法，返回一个整数数据
13 public static Integer getInteger(Supplier<Integer> sup){
14 return sup.get();
15 }
16
17 //定义一个方法，返回一个字符串数据
18 public static String getString(Supplier<String> sup){
19 return sup.get();
20 }
21 }
Supplier接口练习之获取最大值
1 /*案例需求
2 定义一个类(SupplierTest)，在类中提供两个方法
3 一个方法是：int getMax(Supplier sup) 用于返回一个int数组中的最大值
4 一个方法是主方法，在主方法中调用getMax方法*/
5 import java.util.function.Supplier;
6 public class SupplierDemo02 {
7 public static void main(String[] args) {
8 //定义一个int数组
9 int[] arr = {19, 50, 28, 37, 46};
10
11
12 int maxNumber = getMax(() -> {
13 int max = arr[0];
14
15 for (int i = 0; i < arr.length; i++) {
16 if (arr[i] > max) {
17 max = arr[i];
18 }
19 }
20 return max;
21 });
22
23 System.out.println(maxNumber);
24 }
25
26 public static int getMax(Supplier<Integer> sup){
27 return sup.get();
28 }
29 }
常用函数式接口之Consumer
Consumer接口:
Consumer接口也被称为消费型接口，它消费的数据的数据类型由泛型指定
常用方法:
Consumer：包含两个方法:
1 void accept(T t) 对给定的参数执行此操作1 default Consumer andThen(Consumer after)返回一个组合的Consumer，依次执行此操作，然后执行after操作
1 import java.util.function.Consumer;
2
3 public class ConsumerDemo {
4 public static void main(String[] args) {
5
6 //操作一：控制台输出字符串
7 operatorString("令狐冲",s -> System.out.println(s));
8 //操作二：将字符串转为StringBuilder，反转后转化为String
9 operatorString("令狐冲",s-> System.out.println(new StringBuilder(s).reverse().toString()));
10
11 System.out.println("--------");
12
13 //传入两个操作使用andThen完成
14 operatorString("令狐冲",s-> System.out.println(s),
15 s -> System.out.println(new StringBuilder(s).reverse().toString()));
16 }
17
18 //定义一个方法，消费一个字符串数据
19 public static void operatorString(String name,Consumer<String> con){
20 con.accept(name);
21 }
22
23 //定义一个方法，用不同的方式消费同一个字符串数据两次
24 public static void operatorString(String name,Consumer<String> con1,Consumer<String> con2){
25 // con1.accept(name);
26 // con2.accept(name);
27 con1.andThen(con2).accept(name);
28 }
29 }
Consumer接口练习之按要求打印信息
1 /*案例需求
2 String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
3 字符串数组中有多条信息，请按照格式：“姓名：XX,年龄：XX"的格式将信息打印出来
4
5 要求：
6 把打印姓名的动作作为第一个Consumer接口的Lambda实例
7 把打印年龄的动作作为第二个Consumer接口的Lambda实例
8 将两个Consumer接口按照顺序组合到一起使用*/
9 import java.util.function.Consumer;
10
11 public class ConsumerTest {
12
13 public static void main(String[] args) {
14 String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33"};
15
16 printInfo(
17 strArray,
18 str -> System.out.print("姓名："+str.split(",")[0]),
19 str-> System.out.println(",年龄："+Integer.parseInt(str.split(",")[1]))
20 );
21
22 }
23
24 //定义一个方法，完成两个操作
25 public static void printInfo(String[] strArray, Consumer<String> con1,Consumer<String> con2){
26 for (String str:strArray) {
27 con1.andThen(con2).accept(str);
28 }
29 }
30 }
常用函数式接口之Predicate
Predicate接口:
Predicate接口通常用于判断参数是否满足指定的条件
常用方法:
1 boolean test(T t) 对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值1 default Predicate negate() 返回一个逻辑的否定，对应逻辑非1 default Predicate and(Predicate other) 返回一个组合判断，对应短路与1 default Predicate or(Predicate other) 返回一个组合判断，对应短路或
1 test01:
2 import java.util.function.Predicate;
3
4 public class PredicateDemo {
5 public static void main(String[] args) {
6
7 boolean b1 = checkString("Hello", s -> s.length() > 8);
8 System.out.println(b1);
9 boolean b2 = checkString("HelloWorld", s -> s.length() > 8);
10 System.out.println(b2);
11
12 }
13
14 //判断给定的字符串是否满足要求
15 public static boolean checkString(String s, Predicate<String> pre){
16 return pre.test(s);
17 }
18 }1 test02:
2 import java.util.function.Predicate;
3
4 public class PredicateDemo02 {
5 public static void main(String[] args) {
6
7 boolean b1 = checkString("Hello", s -> s.length() > 8);
8 System.out.println(b1);
9 boolean b2 = checkString("HelloWorld", s -> s.length() > 8);
10 System.out.println(b2);
11
12 System.out.println("--------");
13
14 boolean b3 = checkString("Hello", s -> s.length() > 8, s -> s.length() < 15);
15 System.out.println(b3);
16 boolean b4 = checkString("HelloWorld", s -> s.length() > 8, s -> s.length() < 15);
17 System.out.println(b4);
18 }
19
20 //同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
21 public static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2 ){
22 //return pre1.and(pre2).test(s);
23 return pre1.or(pre2).test(s);
24
25 }
26
27 //判断给定的字符串是否满足要求
28 public static boolean checkString(String s, Predicate<String> pre){
29 return pre.negate().test(s);
30 }
31 }
Predicate接口练习之筛选满足条件数据
1 /*练习描述
2 String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
3 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并
4 遍历ArrayList集合
5 同时满足如下要求：姓名长度大于2；年龄大于33
6
7 分析
8 有两个判断条件,所以需要使用两个Predicate接口,对条件进行判断
9 必须同时满足两个条件,所以可以使用and方法连接两个判断条件*/
10 import java.util.ArrayList;
11 import java.util.function.Predicate;
12
13 public class PredicateTest {
14 public static void main(String[] args) {
15 String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
16
17 ArrayList<String> arr = myFilter(
18 strArray,
19 s -> s.split(",")[0].length() > 2,
20 s -> Integer.parseInt(s.split(",")[1]) > 33
21 );
22
23 //遍历ArrayList集合
24 for (String ss:arr) {
25 System.out.println(ss);
26 }
27 }
28
29 private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1,Predicate<String> pre2) {
30 ArrayList<String> arrayList=new ArrayList<>();
31
32 for (String str:strArray) {
33 if (pre1.and(pre2).test(str)) {
34 arrayList.add(str);
35 }
36 }
37 return arrayList;
38 }
39 }
常用函数式接口之Function
Function接口:
Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值
常用方法:
1 R apply(T t) 将此函数应用于给定的参数1 default Function andThen(Function after) 返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果
1 示例：
2 import java.util.function.Function;
3
4 public class FunctionDemo {
5 public static void main(String[] args) {
6 //操作一：
7 convert("100",s -> Integer.parseInt(s));
8
9 //操作二：
10 convert(100,i->String.valueOf(100+566));
11
12 //使用andThen的方式连续执行两个操作
13 convert("100",s -> Integer.parseInt(s),i ->String.valueOf(i+566) );
14
15 }
16 //定义一个方法，把一个字符串转换int类型，在控制台输出
17 public static void convert(String s, Function<String,Integer> fun){
18 Integer i = fun.apply(s);
19 System.out.println(i);
20 }
21
22 //定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
23 public static void convert(Integer i, Function<Integer,String> fun){
24 String s = fun.apply(i);
25 System.out.println(s);
26 }
27
28 //定义一个方法，把一个字符串转换int类型，把int类型的数据加上一个整数之后，转为字符串在控制台 输出
29 public static void convert(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){
30 String ss = fun1.andThen(fun2).apply(s);
31 System.out.println(ss);
32 }
33 }
Function接口练习之按照指定要求操作数据
1 /*练习描述
2 String s = "林青霞,30";
3 请按照我指定的要求进行操作：
4 1:将字符串截取得到数字年龄部分
5 2:将上一步的年龄字符串转换成为int类型的数据
6 3:将上一步的int数据加70，得到一个int结果，在控制台输出
7 请通过Function接口来实现函数拼接*/
8 import java.util.function.Function;
9
10 public class FunctionTest {
11 public static void main(String[] args) {
12 String s = "林青霞,30";
13 convert(
14 s,
15 ss->s.split(",")[1],
16 ss->Integer.parseInt(ss),
17 ss->String.valueOf(ss+70));
18 }
19
20 private static void convert(String s, Function<String,String> fun1, Function<String,Integer> fun2,Function<Integer,String> fun3) {
21 String ss = fun1.andThen(fun2).andThen(fun3).apply(s);
22
23 System.out.println(ss);
24 }
25 }
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
