Java中的特殊接口：常用的函数式接口 部分（二）

Supplier接口

Supplier:包含一个无参的方法

• T get():获得结果
• 该方法不需要参数，他会按照某种实现逻辑（由Lambda表达式实现）返回一个数据
• Sopplier接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据给我们用

import java.util.function.Supplier;

public class Supperdame {
    public static void main(String[] args) {
        String s=use(()-> "张三丰");
        System.out.println(s);
        int i = use1(() -> 100);
        System.out.println(i);
    }
    //返回一个字符串
    private static String  use(Supplier<String> sd){
        return sd.get();
    }
    //返回一个整数
    private static int  use1(Supplier<Integer> sd){
         return sd.get();
    }
}

使用Supplier接口和Lambda表达式来设计一个方法返回数组中的最大值

public class Suppliedemo {
    public static void main(String[] args) {
        int[] s={1,24,435,4536,34,53234,534,2334,523,345};
        int w = use(() -> {
            int max = s[0];
            for (int e = 0; e < s.length; e++) {
                if (max< s[e]) {
                    max = s[e];
                }
            }
            return max;
        });
        System.out.println(w);
    }
    private  static int use(Supplier<Integer> sd){
        return sd.get();
    }
}

Consumer接口

Consumer:包含两个方法

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

Consumer接口的应用实例

public class Consumerdemo {
    public static void main(String[] args) {
        //使用Lambda表达式，输出此字符串
        use("刘亦菲",(s)-> System.out.println(s));
        //使用引用，输出此字符串
        use("王祖贤",System.out::println);
        //使用Lambda表达式将字符串反转并大写
        use("abcdefghijklmn",s-> System.out.println(new StringBuilder(s).reverse().toString()));
        //使用Lambda表达式实现asd方法
        asd("林青霞",(s)-> System.out.println(s),(s)-> System.out.println(new StringBuilder(s).reverse().toString()));
    }
    //消费一个字符串
    private  static void use(String s, Consumer<String> a){
        a.accept(s);
    }
    //用同一个方法消费一个字符串两次
    private static void asd(String s,Consumer<String> sd,Consumer<String> ds){
        sd.accept(s);
        ds.accept(s);
        //可以使用andthen方法改进该方法体，使其更简洁
        sd.andThen(ds).accept(s);
    }
}

//Consumer接口的具体应用：将一个字符串数组拆分，并按格式输出

public class Consumerdemo2 {
    public static void main(String[] args) {
        String [] we={"林青霞,30","张曼玉,35","王祖贤,39"};
        use(we,s-> System.out.print("姓名:"+s.split(",")[0]),
                s->System.out.println("，年龄:"+s.split(",")[1])
        );
    }
    private static void use(String[] s, Consumer<String> sd,Consumer<String> ds){
        for(String as:s){
            sd.andThen(ds).accept(as);
        }
    }
}

//输出结果：
姓名:林青霞，年龄:30
姓名:张曼玉，年龄:35
姓名:王祖贤，年龄:39

Predicate接口

Predicate：常用的四个方法：

boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现)

default Predicate negate():返回一个逻辑的否定，对应逻辑非

default predicate and(Prediccate):返回一个组合判断，对应短路与

default Predicate or(Predicate):返回一个组合判断，对应短路或

Predicate:接口常用于判断参数是否满足指定的条件

Predicate接口的应用实例：

public class predicatedemo {
    public static void main(String[] args) {
       /* Boolean d = use("Predicate", (s) -> {
            return s.length() > 7;
        });
        System.out.println(d);*/
        Boolean d = use("helloworld", s -> s.length() > 6);
        System.out.println(d);
        Boolean ss = use("hello", s -> s.length() > 6);
        System.out.println(ss);
        //第二个方法的使用
        Boolean b1 = asd("hellow", s -> s.length() > 5, s -> s.length() < 8);
        System.out.println(b1);
        Boolean d2 = asd("java", s -> s.startsWith("j"), s -> s.length() < 5);
        System.out.println(d2);
    }
    //根据条件判断字符串
    //返回值类型是整个Lambda表达式的返回值
    private static Boolean use(String s,Predicate<String> sd){
        //return sd.negate().test(s);
        return sd.test(s);
    }
    //同一个字符串给出量的不同的判断条件，最后把这两个的结果做逻辑与运算的结果作为最终结果
    private  static Boolean asd(String s,Predicate<String> s1,Predicate<String> s2){
        //未优化
        boolean d1 = s1.test(s);
        boolean d2 = s2.test(s);
        boolean b = d1 && d2;
        return b;
        //优化
        //短路与
        //return s1.and(s2).test(s);
        //短路或
        return s1.or(s2).test(s);
    }
}

Predicate的接口实战

public class Predicatedemo1 {
    //String[] str ={"林青霞,30","刘岩,34","张曼玉,35","王祖贤,33",“貂蝉,31”};
    //字符串数组中有多条信息，通过Predicate接口的拼装将符合要求的筛选到集合中
    //要求：姓名长度大于二，年龄大于33
    public static void main(String[] args) {
        String[] str ={"林青霞,30","刘岩,34","张曼玉,35","王祖贤,33","貂蝉,31"};
        ArrayList<String> asd = asd(str, s -> s.split(",")[0].length() > 2, s -> Integer.parseInt(s.split(",")[1]) > 33);
        System.out.println(asd);

    }
    private static ArrayList<String> asd(String [] str, Predicate<String> p1,Predicate<String> p2){
        ArrayList<String> as = new ArrayList<>();
        for(String s:str){
            boolean dd = p1.and(p2).test(s);
            if(dd){
                as.add(s);
            }
        }
        return as;
    }
}

Function接口

Function:常用的两个方法

• R apply:将此函数应用于给定的参数
• andthen:返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

Function<T,R>接口通常用于对于参数进行处理，转换（处理逻辑由Lambda表达式实现）然后返回一个新的值

Function接口的应用实例

public class unctiondem {
    public static void main(String[] args) {
        //方法一
        int asd = asd("1000", s -> Integer.parseInt(s));
        System.out.println(asd);
        //方法二
        String ss = asd(12343, s -> new String().valueOf(s + 10));
        System.out.println(ss);
        //方法三
        int i = sa("123", s -> Integer.parseInt(s) + 234);
        System.out.println(i);
    }
    //方法一，定义一个方法，将一个字符串转换成为一个int类型的数据然后输出
    private static int asd(String s, Function<String,Integer>as){
        Integer sd = as.apply(s);
        return sd;
    }
    //方法二，定义一个方法，把一个int类型的数据加上10，然后转换成字符串
    private  static String asd(int e,Function<Integer,String> sd){
        return sd.apply(e);
    }
    //方法三，定义一个方法，把一个字符串转换成int类型的数据，把int类型的数据加上一个整数后在控制台输出
    private static int sa(String s,Function<String,Integer> sd){
        return sd.apply(s);
    }
}

Founction接口实战

public class Funcyiondemo {
    /* String s="林青霞,30";
    1.将字符串截取到数字年龄部分
    2.将上一步的年龄字符串转换成int类型的数据
    3.将上一步的int数据加70，得到一个int结果，在控制台输出
     */
    public static void main(String[] args) {
        String s="林青霞,30";
        int i = asd(s, s1 -> Integer.parseInt(s1.split(",")[1]), s2 -> s2 + 70);
        System.out.println(i);
    }
    private static int asd(String s, Function<String,Integer> sd,Function<Integer,Integer>as){
        return sd.andThen(as).apply(s);
    }
}