code学习

JAVA 函数式接口

函数式接口概述

概念:

有且仅有一个抽象方法的接口

如何检测一个接口是不是函数式接口?

    • @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 }