函数式接口的的使用

函数式接口的使用

Function、Predicate、Supplier、Consumer

介绍

什么是函数式接口

接口中只有一个抽象方法（不包括默认、静态）

如何去定义一个函数式接口

@FunctionalInterface 该注解的作用：约束接口中只能有一个抽象方法

定义一个接口 提供一个抽象方法

@FunctionalInterface
interface Cal{
    int calOperation(int a,int b);
}

Lambda表达式的格式

（参数） 调用方法、传递参数

​ —> 将小括号中的参数传递到大括号中

​ {} 实现代码的方法体

特点

通过传入不同的function，实现了【同一个方法中实现不同的操作，在实际开发中可以大大减少很多重复的代码，实现逻辑的复用】

函数式编程和非函数式编程的区别

• 函数式编程：先考虑传入的参数 再考虑方法的实现
• 非函数式编程：先定义好方法，再传入指定的参数

/**
 * @author zhanghuan
 * @date 2020/6/29 11:35 上午
 */
public class FuncationalInterfaceTest {

    public static void showTime(CurrentTimePrinter printer){
        printer.printCurrentTime();
    }
    public static void getResult(int a,int b,Cal cal){
        int res = cal.calOperation(a,b);
        System.out.println(res);
    }
    public static void convert(int num,NumbertoString numbertoString){
        String s = numbertoString.convert(num);
        System.out.println(s);
    }
    public static void main(String[] args) {
        showTime(()-> System.out.println(System.currentTimeMillis()));
        getResult(10,5,(a,b)->a*b);
        convert(999,Integer::toHexString);
    }
}

@FunctionalInterface
interface CurrentTimePrinter{
    void printCurrentTime();
}
@FunctionalInterface
interface Cal{
    int calOperation(int a,int b);
}
@FunctionalInterface
interface NumbertoString{
    String convert(int num);
}

使用函数式编程来实现延迟加载

Predicate的使用（构造断言式）：

简介：

predicate是一个接口，含有一个抽象方法test()，含有4个由default修饰的具体实现方法and()、or()、negate()、isEquals()

and()对应java的连接符 &&；

or()对应java的连接符 || ；

negate()对应java的连接符 ! ；

isEquals对应java的连接符 == ；

/**
 * Predicate<T>函数式接口
 *
 * @author zhanghuan
 * @date 2020/6/29 3:17 下午
 */
public class Test03 {
    /**
     * boolean test(T t);  获取布尔类型结果
     * @param s
     * @param pre
     * @return
     */
    public static boolean checkString(String s, Predicate<String> pre){
        return pre.test(s);
    }

    /**
     * and();   代表&&的意思
     *
     *   传递两个Predicate接口,比如：
     *  一个用于判断字符串的长度是否大于5
     *  一个用于判断字符串中是否包含a
     *   两个条件必须同时满足
     * @param s
     * @param pre
     * @return
     */
    public static boolean checkStringAnd(String s, Predicate<String> pre1,Predicate<String> pre2){
        return pre1.and(pre2).test(s);
    }

    /**
     * or();   代表||的意思
     * @param s
     * @param pre1
     * @param pre2
     * @return
     */
    public static boolean checkStringOr(String s, Predicate<String> pre1,Predicate<String> pre2){
        return pre1.or(pre2).test(s);
    }

    /**
     * negate取反
     * @param s
     * @param pre
     * @return
     */
    public static boolean checkStringNegate(String s, Predicate<String> pre){
        return pre.negate().test(s);
    }

    /**
     * 方法的参数传递一个包含人员信息的数组
     * 传递两个Predicate接口，用于对数组中信息进行过滤
     * 把满足条件的信息存到ArrayList集合中并返回
     *
     * @return
     */
    public static ArrayList<String> filter(String arr[],Predicate<String> pre1,Predicate<String>pre2){
        ArrayList<String> list = new ArrayList<>();
        for (String s:arr){
            boolean b = pre1.and(pre2).test(s);
            if (b){
                list.add(s);
            }
        }
        return list;
    }


    public static void main(String[] args) {
        String s = "abcdef";
        //长度大于5
        boolean b = checkString(s,str->str.length()>5);
        System.out.println(b);

        //长度大于6并且包含"a"
        boolean and = checkStringAnd(s,str->str.length()>6,str->str.contains("a"));
        System.out.println(and);

        //长度大于6 或者 包含"a"
        boolean or = checkStringOr(s,str->str.length()>6,str->str.contains("a"));
        System.out.println(or);

        //取反
        boolean negate = checkStringNegate(s,str->str.length()>5);
        System.out.println(negate);

        //过滤操作
        String arr[] = {"张小三,男","小红,女","李四,男","小小明,男"};
        ArrayList<String> list = filter(arr, str -> "男".equals(str.split(",")[1])
                , str -> str.split(",")[0].length() > 2);
        list.forEach(System.out::println);


    }
}

Supplier函数式接口-用来做生产的 T get();

/**
 * Supplier<T>函数式接口-用来做生产的
 *
 * T get();
 *
 * @author zhanghuan
 * @date 2020/6/29 2:22 下午
 */
public class Test01 {
    public static void main(String[] args) {
        String s = getString(()->{
            return "hello world";
        });
        System.out.println(s);

        //优化lambda
        String s2 = getString(()->"hello java");
        System.out.println(s2);

        int [] arr = {34,45,23,1,345,-54};
        int maxVal = getMax(()->{
            int max = arr[0];
            for (int i:arr) {
                if (i>max){
                    max = i;
                }
            }
            return max;
        });
        System.out.println(maxVal);
    }

    /**
     * 会返回一个String
     * @param sup
     * @return
     */
    public static String getString(Supplier<String> sup){
        return sup.get();
    }

    /**
     * 返回一个最大值
     * @param sup
     * @return
     */
    public static int getMax(Supplier<Integer> sup){
        return sup.get();
    }
}

Consumer函数式接口-用来做消费的

/**
 * Consumer<T t>函数式接口-用来做消费的
 *
 *
 * @author zhanghuan
 * @date 2020/6/29 2:47 下午
 */
public class Test02 {
    public static void method(String name, Consumer<String> consumer){
        consumer.accept(name);
    }
    public static void method02(String name, Consumer<String> con1,Consumer<String> con2){
        //使用andThen方法，先把两个Consumer接口连接在一起，在消费数据
        //con1连接con2,先执行con1消费数据,在执行con2消费数据
        con1.andThen(con2).accept(name);
    }
    public static void printInfo(String[] arr,Consumer<String> con1,Consumer<String> con2){
        for (String message: arr){
            con1.andThen(con2).accept(message);
        }
    }
    public static void main(String[] args) {
        method("neoooo",(name)->{
            //对传递的字符串进行消费
            //消费方式:直接输出字符串
            //System.out.println(name);

            //消费方式:把字符串进行反转输出
            String reverse = new StringBuffer(name).reverse().toString();
            System.out.println(reverse);
        });
        //调用method02方法，传递一个字符串，两个lambda表达式
        method02("nizhenniubi",(name)->{
            System.out.println(name.toUpperCase());
        },(name)->{
            System.out.println(name.toLowerCase());
        });
        String arr[] = {"zhangsan,male","lisi,male","wanger,female"};
        printInfo(arr,(message)->{
            String name = message.split(",")[0];
            System.out.println("姓名："+name);
        },(message)->{
            String sex = message.split(",")[1];
            System.out.println("性别："+sex+" ");
        });
    }
}

Function<T t,R r>函数式接口
R apply(T t); 数据类型转换

/**
 * @author zhanghuan
 * @date 2020/6/29 4:29 下午
 */
public class Test04 {
    /**
     * Function<T t,R r>函数式接口
     * R apply(T t);    数据类型转换
     * @param s
     * @param function
     */
    public static void change(String s, Function<String,Integer> function){
        //字符串类型的整数 转换为Integer类型的整数
        int in = function.apply(s);
        System.out.println(in);
    }

    /**
     * andThen(Function<T t,R r>);
     * @param s
     * @param fun1
     * @param fun2
     */
    public static void change02(String s,Function<String,Integer> fun1,Function<Integer,String>fun2){
        String ss = fun1.andThen(fun2).apply(s);
        System.out.println(ss);
    }

    public static int change03(String s,Function<String,String> fun1,Function<String,Integer>fun2,Function<Integer, Integer> fun3){
        return fun1.andThen(fun2).andThen(fun3).apply(s);
    }
    public static void main(String[] args) {
        String s = "12345";
        String ss = "小小明,20";
        change(s,str->Integer.parseInt(s));
        change02(s,str->Integer.parseInt(s)+10,i->i+"");
        int num = change03(ss, str -> str.split(",")[1], str -> Integer.parseInt(str), i -> i + 100);
        System.out.println("num: "+num);
    }
}

需要注意的：

• 现有的大多数标准函数接口都支持基本类型。千万不要用带包装类型的基础函数接口来代替基本函数接口。虽然可行，但是它破坏了“基本类型优于装箱基本类型”。使用装箱基本类型进行批量操作处理，最终会导致致命的性能问题

Reference

https://www.cnblogs.com/Auge/p/11528974.html

https://blog.csdn.net/jmj18756235518/article/details/81490966