java中常见的几种函数式接口

Supplier:
Suppler是一个生产型接口,此接口指定什么泛型,那么接口中的get方法就返回什么类型的数据

import java.util.function.Supplier;

public class Demo05SupplierTest {
    private static int getMax(Supplier<Integer> sup) {
        return sup.get();
    }

    public static void main(String[] args) {
        int[]arr = {100,50,200,66,38,88};
        int Max = getMax(()->{
            int max = arr[0];
            for (int i : arr) {
                if (max < i)
                    max = i;
            }
            return max;
        });

        System.out.println("最大值:"+Max);
    }
}

Consumer:
Consumer是一个消费型接口,此接口指定什么泛型,那么接口中的accept方法就返回什么类型的数据

import java.util.function.Consumer;

public class Demo02Consumer_Test {
    private static void getMessage(String[]arr, Consumer<String> con1 ,Consumer<String> con2){
        for (String s : arr) {
            con1.andThen(con2).accept(s);
        }
    }

    public static void main(String[] args) {
        String[]arr = {"hahaha,nv","xixixi,nv","dadada,nan"};

        getMessage(arr,(massage)->{
            String s1 = massage.split(",")[0];
            System.out.print("name:"+s1);
        },(messge)->{
            String s2 = messge.split(",")[1];
            System.out.println(",sex:"+s2);
        });
    }
}

Predicate
用于判断的方法,返回值是布尔值,有三种默认方法and(与), or(或), negate(非)

import java.util.function.Predicate;

public class Demo01Predicate {
    private static boolean chickStringLength(String s, Predicate<String> pre){
        return pre.test(s);
    }

    public static void main(String[] args) {
        String s1 = "sa;fasf";
        String s2 = "1fdfsa";

        boolean b = chickStringLength(s1,s -> s.contains("a"));
        boolean b1 = chickStringLength(s2,s -> s.length()>6);
        System.out.println(b+","+b1);
    }
}

Predicate的默认方法之and,把判断结果进行相与运算:

import java.util.function.Predicate;

public class Demo02Predicate_and {
    private static boolean chickString_and(String s, Predicate<String>pre1, Predicate<String>pre2){
        return pre1.and(pre2).test(s);  //等价于return pre1.test(s) && pre2.test(s);
    }

    public static void main(String[] args) {
        String s = "adfghjd";
        //lambda表达式
        boolean b = chickString_and(s,
                //判断长度是否大于6
                s1 -> s1.length()>6,
                //判断是否包括"a"
                s1 -> s1.contains("a") );
        System.out.println(b);  //输出两个判断结果的"与".
    }
}

另一个使用案例:

import java.util.ArrayList;
import java.util.function.Predicate;

//对给定的数组中的元素进行筛选,选出名字是4个字的女生
public class Predicate_test {
    private 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[] arr = {"古力娜扎,女","迪丽热巴,女","ydaiq,女"};
        //调用Predicate_test方法
        ArrayList<String> list = filter(arr,
                //判断名字长度
                s -> s.split(",")[0].length() == 4,
                //判断性别
                s -> s.split(",")[1].equals("女"));

        //遍历list集合
        for (String s : list) {
            System.out.println(s);
        }
    }
}

//结果: 古力娜扎,女
//     迪丽热巴,女

Predicate的默认方法之or,把判断结果进行"或"运算:

import java.util.function.Predicate;

public class Demo03Predicate_or {
    private static boolean chinckString_or(String s, Predicate<String> pre1, Predicate<String> pre2){
        return pre1.or(pre2).test(s);   //等效于return pre1.test(s) || pre2.test(s);
    }

    public static void main(String[] args) {
        String s = "aadfghfsd";
        boolean b = chinckString_or(s,
                //判断是否长于6,
                s1 -> s1.length()>6,    //成立
                //判断是否包含"j"
                s1 -> s1.contains("j")); //不成立
        //只有一条成立,进行或运算结果为true所以输出true
        System.out.println(b);
    }
}

Predicate的默认方法之negate,把判断结果取"非":

import java.util.function.Predicate;

public class Demo04Predicate_negate {
    private static boolean chinckString_negate(String s, Predicate<String> pre) {
        return pre.negate().test(s);   //等效于return !pre1.test(s);
    }

    public static void main(String[] args) {
        String s = "aaaaaa";
        //对判断结果进行取反
        boolean b = chinckString_negate(s, s1 -> s1.contains("a"));
        //判断结果是true,所以输出false
        System.out.println(b);
    }
}

Function:
用于一个类型的数据转换为另一个类型,前者是前置条件,后者是后置条件.Function接口中主要的抽象方法是" apply ",使用场景,例如:将 String 类型转换为 Integer 类型.

import java.util.function.Function;

//Function的作用是数据类型的转换
public class Demo01Function {
    private static Integer change(String s , Function<String,Integer>fun){
        return fun.apply(s);
    }

    public static void main(String[] args) {
        String s = "123456";

        //调用change方法
        int in = change(s,s1 -> Integer.parseInt(s));
        System.out.println(in);  
        //结果:123456
    }
}

Function接口的另一个抽象方法 andthen ,该抽象方法用于拼接两个Function接口

import java.util.function.Function;

public class demo02Funcation_two_change {
    private static String change(String s, Function<String,Integer> fun1, Function<Integer,String> fun2){
        String ss = fun1.andThen(fun2).apply(s);
        return ss;
    }

    public static void main(String[] args) {
        String s = "123";

        String ss = change(s, (s1)->{return Integer.parseInt(s1) + 10;} ,(s2) -> { return s2+"";});
        System.out.println(ss);

        //简化lambda表达式
        String ss1 = change(s, s1 -> Integer.parseInt(s) + 20, s2 -> s2+"");
        System.out.println("简化的Lambda表达式:" + ss1);
        
        //输出结果:  133
        //          简化的Lambda表达式:143
    }
}

Function接口的抽象方法 andthen ,还能用于更多的接口的连接,下面给一个三个接口的例子:

import java.util.function.Function;
//先截取字符串的数字部分,后转换为Integer类型,然后把Integer类型的数字加100,最后定型为Integer.
public class demo03Function_three_change {
    private static Integer change(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 = "ydaiq,19";

        int in = change(s, s1 -> s.split(",")[1], s1 -> Integer.parseInt(s1), s1 -> s1 + 100);
        System.out.println(in);
    }
}