函数式接口

函数式接口

1.1概述

函数式接口：有且仅有一个抽象方法的接口

​ Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

@FunctionalInterface//判断接口是否为函数式接口，可以省略
public interface MyInterface {
    void show();
}

1.2函数式接口作为方法的参数

/*
    定义一个类，在类中提供了两个方法
        方法1:startThread(Runnable r); 方法参数是一个函数式接口
        主方法中调用startThread();方法
 */
public class RunnableDemo {
    public static void main(String[] args) {

        //匿名内部类的方式
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });
        //Lambda表达式
        startThread(()-> System.out.println(Thread.currentThread().getName()+"线程启动了"));
        //如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递
    }
    public static void startThread(Runnable r){
        new Thread(r).start();
    }
}

1.3函数式接口作为方法的返回值

/*
    定义一个类(ComparatorDemo),在类中提供两个方法
        方法1:Comparator<String> getComparator() 方法的返回值是一个函数式接口
        主方法中调用getComparator方法
 */
public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> arr = new ArrayList<>();
        arr.add("aaa");
        arr.add("bb");
        arr.add("c");
        System.out.println("排序前："+arr);

        //Collections.sort(arr); //自然排序
        Collections.sort(arr,getComparator());
        System.out.println("排序后："+arr);
    }
    public static Comparator<String> getComparator(){
        //匿名内部类的方法实现
        return new Comparator<String>() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length()-s2.length();
            }
        };
        //Lambda表达式
        return(s1,s2)->s1.length()-s2.length();
    }
}

1.4常用的函数式接口

• Supplier接口
• Consumer接口
• Predicate接口
• Function接口

1.5Supplier接口

Supplier:包含一个无参的方法

• T get(); 获得结果

  该方法不需要参数，它会按照某种是想逻辑(由Lambda表达式实现)返回一个数据

  Supplier接口也被称为生产性接口，如果我们制定了接口的泛型是什么类型，那么接口中get方法就会产生什么类型的数据

public class MySupplierDemo {
    public static void main(String[] args) {

        String s=getString(()-> "李逍遥");
        System.out.println(s);

        int i=getInteger(()->23);
        System.out.println(i);
    }
    //定义一个方法，返回一个字符串数据
    public static String getString(Supplier<String> sup){
        return sup.get();
    }
    //返回一个整数数据
    public static Integer getInteger(Supplier<Integer> sup){
        return sup.get();
    }
}

1.5.1Supplier接口获取最大值

/*
    获取最大值
    定义一个类(SupplierTest),在类中定义两个方法
        方法1：int getMax(Supplier<Integer> sup);用于返回一个int数组中的最大值
        主方法中调用getMax()方法
 */
public class SupplierTest {
    public static void main(String[] args) {
        //定义一个数组
        int []arr={22,54,78,11,35};
        int maxValue=getMax(()->{
            int max=arr[0];
            for (int i=1;i<arr.length;i++){
                if (max<arr[i]){
                    max=arr[i];
                }
            }
            //返回最大值
            return max;
        });
        System.out.println(maxValue);
    }
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

1.6Consumer接口

Consumer:包含两个方法

• void accept(T t):对给定的参数执行此操作
• default ConsumerandTher(Consumer after); 返回一个组合的Consumer，依次执行此操作，然后执行after操作
• Consumer接口 也被称为消费型接口，它消费的数据的数据类型由泛型指定

public class ConsumerDemo {
    public static void main(String[] args) {
        operatorString("李逍遥",s -> System.out.println(s));
//        operatorString("李逍遥",System.out::println);//方法引用
        //反转输出
        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()));
    }
    //定义一个方法，消费了一个字符串数据
    public static void operatorString(String name, Consumer<String> con){
        con.accept(name);
    }
    //定义一个方法，用不同的方式消费同一个字符串数据两次
    public static void operatorString(String name,Consumer<String> con1,Consumer<String> con2){
//        con1.accept(name);
//        con2.accept(name);
        con1.andThen(con2).accept(name);
    }
}

1.6.1Consumer接口按要求打印信息

/*
    String[] strArray={"迪迦,28","李逍遥,30","张三丰,35"};
    字符串数组中有多条信息，按照格式："姓名：xx,年龄：xx"的格式打印出来
    要求:
        把打印姓名的动作作为第一个Consumer接口的Lambda实例
        把打印年龄的动作作为第二个Consumer接口的Lambda实例
        将两个Consumer接口按照顺序组合到一起使用
 */
public class ConsumeTest {
    public static void main(String[] args) {
        String[] strArray={"迪迦,28","李逍遥,30","张三丰,35"};
        printInfo(strArray,(String str)->{
            String name=str.split(",")[0];
            System.out.print("姓名:"+name);
        },(String str)->{
            String age=str.split(",")[1];
            int Age=Integer.parseInt(age);
            System.out.println(",年龄:"+Age);
        });
        System.out.println("----------");
        printInfo(strArray,str-> System.out.print("姓名："+str.split(",")[0]),str-> System.out.println(",年龄："+Integer.parseInt(str.split(",")[1])));
    }
    public static void printInfo(String [] strArray, Consumer<String> con1,Consumer<String> con2){
        for (String str:strArray){
            con1.andThen(con2).accept(str);
        }
    }
}

1.7Predicate接口

Predicate:常用的四个方法

• boolean test(T t)；队给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
• default Predicatenegate();返回一个逻辑的否定，对应逻辑非
• default Predicateand(Predicate other);返回一个组合判断，对应逻辑与
• default Predicateor(Predicate other);返回一个组合判断，对应逻辑或
• Predicate接口通常用于判断参数是否满足指定的条件

/*
    - 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 PredicateDemo {
    public static void main(String[] args) {
        //boolean test(T t)；
        boolean b1 = checkString("hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = checkString("helloWorld", s -> s.length() > 8);
        System.out.println(b2);
        System.out.println("--------------");

        //default Predicate<T>and(Predicate other);
        boolean b = checkString("hello", s -> s.length() > 6, s -> s.length() > 3);
        System.out.println(b);
    }
    //boolean test(T t)；队给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
    private static boolean checkString(String s, Predicate<String> pre){
        //return pre.test(s);
        return pre.negate().test(s);//返回一个逻辑的否定，对应逻辑非
    }
    //default Predicate<T>and(Predicate other);返回一个组合判断，对应短路与
    private static boolean checkString(String s,Predicate<String> pre1,Predicate<String> pre2){
//        return pre1.and(pre2).test(s);//与
        /*
        boolean b1=pre1.test(s);
        boolean b2=pre2.test(s);
        return b2;
         */
        return pre1.or(pre2).test(s);//或
    }
}

1.7.1按要求打印信息

/*
    String[] strArray={"迪迦,28","李逍遥,30","张三丰,35"};
    字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayList中，并遍历集合
    同时满足以下条件：
        姓名长度大于2，年龄大于33；
 */
public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray={"迪迦,28","李逍遥,30","张三丰,35"};

        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);
        }
    }
    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;
    }
}

1.8Function接口

Function<T,R>:常用的两个方法

• R aaply(T t); 将此函数应用于给定的参数
• default Function andThen(Function after)； 发明一个组合函数、首先将函数应用于输入，然后将after函数应用于结果
• Function<T,R> 接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现），然后返回一个新的值

public class FunctionDemo {
    public static void main(String[] args) {
        //String->int
        convert("100",s -> Integer.parseInt(s));

        //int+整数->String
        convert(100,i ->String.valueOf(i+55) );

        //String->int->String
        convert("100",s -> Integer.parseInt(s)+56,i->String.valueOf(i));
    }
    //把一个String类型数据转换为一个int类型数据
    private static void convert(String s, Function<String,Integer> fun){
        Integer i = fun.apply(s);
        System.out.println(i);
    }
    //定义一个方法，把一个int类型数据加上一个整数后，转为字符串再控制台输出
    private static void convert(Integer 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);
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }
}

/*
    String s="李逍遥,28"；
    请按照要求进行操作：
        1、将字符串截取得到数字年龄部分
        2、将上一步的年龄字符串转换成为int类型的数据
        3、将上一步的int数据加70的，得到一个int结果，在控制台输出
    通过Function接口实现函数拼接
 */
public class FunctionTest {
    public static void main(String[] args) {
        String s="李逍遥,28";
        convert(s,ss->ss.split(",")[1],Integer::parseInt,i->i+70);
        // "28"->28->28+70->98
    }
    private static void convert(String s, Function<String,String> fun1,Function<String,Integer> fun2,Function<Integer,Integer> fun3){
        int i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}