JAVA常用函数式接口

Java中的常用函数式接口

本文介绍四种常用的函数式接口

1.Supplier接口（生产接口）

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

下面是它的一个简单应用

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(() -> "ljy");
        System.out.println(s);

        Integer i = getInteger(() -> 555);
        System.out.println(i);
    }

    //定义一个方法返回一个字符串
    private static String getString(Supplier<String> sup) {
        return sup.get();
    }

    //定义一个方法返回一个整数数字
    private static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }
}

2.Consumer接口（消费接口）

Consumer<T>:包含两个方法

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

下面有几个简单的案例

public class ConsumerDemo {
    public static void main(String[] args) {
        //lambda表达式
        operatorString("ljy", s -> System.out.println(s));
        //方法引用
        operatorString("ljy",System.out::println);

        operatorString("ljy",s-> System.out.println(new StringBuilder(s).reverse().toString()));

        operatorString("ljy",s-> System.out.println(s),s-> System.out.println(new StringBuilder(s).reverse().toString()));
    }

    private static void operatorString(String name, Consumer<String> con) {
        con.accept(name);
    }

    private static void operatorString(String name,Consumer<String>con1,Consumer<String>con2){
        con1.andThen(con2).accept(name);
    }
}

 

import java.util.function.Consumer;

public class ConsumerDemo2 {
    public static void main(String[] args) {
        String[] strArray={"ljy,18","znx,19","zsy,20"};

        printInfo(strArray,str-> System.out.print("姓名："+str.split(",")[0]),
                str-> System.out.println(",年龄："+str.split(",")[1]));
    }

    //info（信息，情报）
    private static void printInfo(String[] strArray, Consumer<String>con1,Consumer<String>con2){
        for(String str:strArray){
            con1.andThen(con2).accept(str);
        }
    }
}

3.Predicate接口（判断接口）

Predicate<T>:常用的四个方法

• boolean test(T t):对给定的参数进行判断(判断逻辑由Lambda表达式实现)，返回一个布尔值
• default Predicate<T> negate():返回一个逻辑的否定，对应逻辑非
• default Predicate<T> and(Prduicate other):返回一个组合判断，对应短路与
• default Predicate<T> or(Predicate other):返回一个组合判断，对应短路或

下面同样给出下面的简单案列

public class PredicateDemo1 {
    public static void main(String[] args) {
        boolean b1 = cheakString("hello", s -> s.length() > 8);
        System.out.println(b1);
        boolean b2 = cheakString("helloworld",s->s.length()>8);
        System.out.println(b2);
    }

    private static boolean cheakString(String s, Predicate<String> pre){
        return pre.test(s);
        //若要使结果相反
        //return pre.negate().test(s);
    }
}

import java.util.function.Predicate;

public class PredicateDemo2 {
    public static void main(String[] args) {
        boolean b = cheakString("helloworld", s -> s.length() > 5, s -> s.length() < 8);
        System.out.println(b);
    }

    private static boolean cheakString(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 b1&&b2;

        //pre1.or(pre2).test(s);
    }
}

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

public class PredicateDemo3 {
    public static void main(String[] args) {
        String[] strArray= {"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"};
        ArrayList array = array(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);
        System.out.println(array);
    }

    private static ArrayList array(String[] s, Predicate<String> pre1, Predicate<String>pre2){
        ArrayList array = new ArrayList();
        for(String str:s) {
            if(pre1.and(pre2).test(str)){
                array.add(str);
            }
        }
        return array;
    }
}

4.Function接口（转换接口）

• Function<T,R>︰常用的两个方法
• R apply(Tt):将此函数应用于给定的参数
• default V> Function andThen(Function after):返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值

下面给出以下案列

import java.util.function.Function;

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

        convert(100, i -> String.valueOf(i + 556));

        convert("100",s -> Integer.parseInt(s),i->String.valueOf(i+556));
    }

    //定义一个方法，把一个字符串转换为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(int 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);
        System.out.println(ss);

        //可以用andThen改进
        //fun1.andThen(fun2).apply(s);
    }
}

//练习
//    Strings ="ljy,18";
//    请按照我指定的要求进行操作:
//    1:将字符串截取得到数字年龄部分
//    2:将上一步的年龄字符串转换成为int类型的数据
//    3:将上一步的int数据加70，得到一个int结果，在控制台输出请通过Function接口来实现函数拼接
//    常

import java.util.function.Function;

public class FunctionDemo2 {
    public static void main(String[] args) {
        convert("ljy,18",s -> s.split(",")[1],s -> Integer.parseInt(s),
                i->i+70);
    }

    private static void convert(String s, Function<String,String>fun1,
                                Function<String,Integer>fun2,
                                Function<Integer,Integer>fun3){
        System.out.println(fun1.andThen(fun2).andThen(fun3).apply(s));
    }
}

运用好这些函数接口还是要掌握Lambda表达式的运用