Java——函数式接口、Supplier接口、Consumer接口、Predicate接口、Function接口

Java——函数式接口、Supplier接口、Consumer接口、Predicate接口、Function接口

• 一、函数式接口概述
• 二、函数式接口作为方法的参数
• 三、函数式接口作为方法的返回值
• 四、常用的函数式接口
• 五、Supplier接口
• 六、Consumer接口
• 七、Predicate接口
• 八、Function接口

一、函数式接口概述

• 函数式接口：有且仅有一个抽象方法的接口
• 函数式接口是Lambda表达式的前提
• 用@FunctionalInterface进行注解

@FunctionalInterface
public interface MyInterface {
    void show();
}

public class MyInterfaceDemo {
    public static void main(String[] args) {
        MyInterface my = () -> System.out.println("函数式接口");
        my.show();
    }
}

二、函数式接口作为方法的参数

1、例子

① 需求

定义一个类(RunnableDemo)，在类中提供两个方法

• startThread(Runnable r)，方法参数Runnable是一个函数式接口
• 主方法，调用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() + "线程启动了"));
    }

    private static void startThread(Runnable r) {
       /* Thread t = new Thread(r);
        t.start();*/
        //上述代码可以简化为
        new Thread(r).start();
    }
}

如果方法的参数是一个函数式接口，可以使用Lambda表达式作为参数传递

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

1、例子

① 需求

定义一个类(ComparatorDemo)，在类中提供两个方法

• Comparator< String > getComparator()，方法返回值Comparator是一个函数式接口
• 主方法，调用getComparator方法

② 代码实现

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        array.add("ccccc");
        array.add("bbb");
        array.add("d");
        System.out.println("排序前：" + array);
        System.out.println("-------------");

        Collections.sort(array);
        System.out.println("自然排序后：" + array);
        System.out.println("-------------");

        Collections.sort(array, getComparator());
        System.out.println("排序后：" + array);
        System.out.println("-------------");
    }

    private static Comparator<String> getComparator() {
        //实现1：匿名内部类
        /*Comparator comp = new Comparator() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };
        return comp;*/

        //实现2：匿名内部类的简化
       /* return new Comparator() {
            @Override
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        };*/

        //实现3：Lambda表达式
       /* return (String s1,String s2)->{
            return s1.length()-s2.length();
        };*/

        //实现4：Lambda表达式简化
        return (s1, s2) -> s1.length() - s2.length();
    }
}

如果方法的返回值是一个函数式接口，可以使用Lambda表达式作为结果返回

四、常用的函数式接口

• Supplier
• Consumer
• Predicate
• Function

五、Supplier接口

1、Supplier< T >包含一个无参的方法：

• T get()：获得结果。该方法不需要参数，会按照某种实现逻辑（由Lambda表达式实现）返回一个数据

2、Supplier< T >接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会产生什么类型的数据供我们使用

3、代码演示

import java.util.function.Supplier;

public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(() -> "zlx");
        System.out.println(s);
        int i = getInteger(() -> 15);
        System.out.println(i);
    }

    private static Integer getInteger(Supplier<Integer> sup) {
        return sup.get();
    }

    private static String getString(Supplier<String> sup) {
        return sup.get();
    }
}

4、Supplier接口练习之获取最大值

① 需求

定义一个类(SupplierTest)，在类中实现两个方法：

• int getMax(Supplier< Integer> sup)用于返回一个int数组中的最大值
• 主方法，调用getMax方法

② 代码实现

import java.util.function.Supplier;

public class SupplierTest {
    public static void main(String[] args) {
        int[] arr = {19, 25, 8, 36, 42};
        int maxValue = getMax(() -> {
            int max = arr[0];
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        });
        System.out.println(maxValue);
    }

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

六、Consumer接口

1、Comsumer< T >包含两个方法：

• void accept(T t)：对给定的参数执行此 *** 作
• default Comsumer< T > andThen(Consumer after)：返回一个组合的Consumer，依次执行此 *** 作，然后执行after *** 作

2、Consumer< T>接口也被称为消费型接口，它消费的数据类型由泛型指定

3、代码演示

import java.util.function.Consumer;

public class ConsumerDemo {
    public static void main(String[] args) {
        //消费一次字符串——输出字符串
        operatorString("zlx", s -> System.out.println(s));
        //上述代码可简化为：
        operatorString("zlx", System.out::println);
        System.out.println("-----------------------");

        //消费一次字符串——反转字符串
        operatorString("zlx", s -> System.out.println(new StringBuilder(s).reverse().toString()));
        System.out.println("-----------------------");

        //消费两次字符串——输出、反转
        operatorString("zlx", 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.accept(name);
        con2.accept(name);*/
        //上面两行等同于下面的语句
        con1.andThen(con2).accept(name);
    }
}

4、Consumer接口练习之按要求打印信息

① 需求

• String[] strArray = {“zlx,18”, “kio,15”,“lop,26”};
• 字符串数组中有多条信息，请按照格式：“姓名：XX，年龄：XX”的格式将信息打印出来
• 要求
  a. 把打印姓名的动作作为第一个Consumer接口的Lambda实例
  b. 把打印年龄的动作作为第二个Consumer接口的Lambda实例
  c. 将两个Consumer接口按照顺序组合到一起使用

② 代码实现

import java.util.function.Consumer;

public class ConsumerTest {
    public static void main(String[] args) {
        String[] strArray = {"zlx,18", "kio,15", "lop,26"};
        printInfo(strArray, str -> System.out.print("姓名：" + str.split(",")[0]),
                str -> System.out.println("，年龄" + str.split(",")[1]));
    }

    private static void printInfo(String[] strArray, Consumer<String> con1, Consumer<String> con2) {
        for (String s : strArray) {
            con1.andThen(con2).accept(s);
        }
    }
}

七、Predicate接口

1、Predicate< T>接口中有4个常用方法：

• boolean test(T t)：对给定的参数进行判断（判断逻辑由Lambda表达式实现），返回一个布尔值

import java.util.function.Predicate;

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

    //判断给定的字符串是否满足条件
    private static boolean checkString(String s, Predicate<String> pre) {
        return pre.test(s);
    }
}

• default Predicate< T> negate()：返回一个逻辑的否定，对应逻辑非

import java.util.function.Predicate;

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

    //判断给定的字符串是否满足条件
    private static boolean checkString(String s, Predicate<String> pre) {
//        return pre.test(s);
        return pre.negate().test(s);
    }
}

• default Predicate< T> and(Predicate other)：返回一个组合判断，对应短路与

import java.util.function.Predicate;

public class PredicateDemo2 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b1);
    }

    //对同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算
    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
       /* boolean b1 = pre1.test(s);
        boolean b2 = pre2.test(s);
        boolean b = b1 && b2;
        return b;*/

        //上述语句等同于：
        return pre1.and(pre2).test(s);
    }
}

• default Predicate< T> or(Predicate other)：返回一个组合判断，对应短路或

import java.util.function.Predicate;

public class PredicateDemo3 {
    public static void main(String[] args) {
        boolean b1 = checkString("hello", s -> s.length() > 8, s -> s.length() < 15);
        System.out.println(b1);
    }

    //对同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑或运算
    private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
        return pre1.or(pre2).test(s);
    }
}

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

3、Predicate接口练习之筛选满足条件数据

① 需求

• String[] strArray = {“zlx,18”, “ko,15”, “lop,26”,“plp,35”};
• 字符串数组中有多条信息，通过Predicate接口的拼接将符合要求的字符串筛选到集合ArrayList中，并遍历ArrayList集合
• 同时满足要求：姓名长度大于2，年龄大于33

② 代码实现

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

public class PredicateTest {
    public static void main(String[] args) {
        String[] strArray = {"zlx,18", "ko,15", "lop,26", "plp,35"};
        ArrayList<String> ss = myFilter(strArray, s -> s.split(",")[0].length() > 2,
                s -> Integer.parseInt(s.split(",")[1]) > 33);
        for (String s : ss) {
            System.out.println(s);
        }
    }

    private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
        ArrayList<String> array = new ArrayList<String>();

        for (String s : strArray) {
            if (pre1.and(pre2).test(s)) {
                array.add(s);
            }
        }

        return array;
    }
}

八、Function接口

1、Function常用的两个方法：

• R apply(T t)：将此函数应用于给定的参数
• default< V> Function andThen(Function after)：返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

2、代码演示

import java.util.function.Function;

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

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

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

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

3、Function接口练习之按照指定要求 *** 作数据

① 需求

• String s = “zlx,18”;
• 按照指定的要求进行 *** 作：
  a.将字符串截取得到数字年龄的部分
  b.将上一步的年龄字符串转换为int类型的数据
  c.将上一步的int数据加70，得到一个int结果，在控制台输出
• 通过Function接口实现函数拼接

② 代码实现

import java.util.function.Function;

public class FunctionTest {
    public static void main(String[] args) {
        String ss = "zlx,18";
        convert(ss, 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) {
        Integer i = fun1.andThen(fun2).andThen(fun3).apply(s);
        System.out.println(i);
    }
}