函数式接口分为哪几类

参考答案

1.  Java8函数式接口类型

• Consumer<T>：消费型接口（void accept(T t)）
• Supplier<T>：供给型接口（T get（））
• Function<T, R>：函数型接口（R apply（T t））
• Predicate<T>：断言型接口（boolean test（T t））

根据不同的使用场景，选择不同的接口。

2. Java8函数式接口实例

2.1  Consumer<T>：消费型接口（void accept(T t)）

消费型接口，有参数，无返回值类型的接口。

/**
     * 消费型接口Consumer<T>
     */
    @Test
    public void test1 () {
        consumo(500, (x) -> System.out.println(x));
    }

    public void consumo (double money, Consumer<Double> c) {
        c.accept(money);
    }

2.2 Supplier<T>：供给型接口（T get（））

供给型接口，只有产出，没有输入，就是只有返回值，没有入参。

/**
     * 供给型接口，Supplier<T>
     */
    @Test
    public void test2 () {
        Random ran = new Random();
        List<Integer> list = supplier(10, () -> ran.nextInt(10));

        for (Integer i : list) {
            System.out.println(i);
        }
    }

    /**
     * 随机产生sum个数量得集合
     * @param sum 集合内元素个数
     * @param sup
     * @return
     */
    public List<Integer> supplier(int sum, Supplier<Integer> sup){
        List<Integer> list = new ArrayList<Integer>();
        for (int i = 0; i < sum; i++) {
            list.add(sup.get());
        }
        return list;
    }

2.3 Function<T, R>：函数型接口（R apply（T t））

函数型接口，输入一个类型得参数，输出一个类型得参数，当然两种类型可以一致。

/**
     * 函数型接口：Function<R, T>
     */
    @Test
    public void test3 () {
        String s = strOperar(" asdf ", x -> x.substring(0, 2));
        System.out.println(s);
        String s1 = strOperar(" asdf ", x -> x.trim());
        System.out.println(s1);
    }

    /**
     * 字符串操作
     * @param str 需要处理得字符串
     * @param fun Function接口
     * @return 处理之后得字符传
     */
    public String strOperar(String str, Function<String, String> fun) {
        return fun.apply(str);
    }

2.4 Predicate<T>：断言型接口（boolean test（T t））

断言型接口，输入一个参数，输出一个boolean类型得返回值。

/**
     * 断言型接口：Predicate<T>
     */
    @Test
    public void test4 () {
        List<Integer> l = new ArrayList<>();
        l.add(102);
        l.add(172);
        l.add(13);
        l.add(82);
        l.add(109);
        List<Integer> list = filterInt(l, x -> (x > 100));
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }

    /**
     * 过滤集合
     * @param list
     * @param pre
     * @return
     */
    public List<Integer> filterInt(List<Integer> list, Predicate<Integer> pre){
        List<Integer> l = new ArrayList<>();
        for (Integer integer : list) {
            if (pre.test(integer))
                l.add(integer);
        }
        return l;
    }

以上，是Java面试题【函数式接口分为哪几类】的参考答案。

输出，是最好的学习方法。

欢迎在评论区留下你的问题、笔记或知识点补充~

—end—