Java8新特性--函数式接口

函数式接口简介:

        函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

        函数式接口可以被隐式转换为 lambda 表达式。

        Lambda 表达式和方法引用（实际上也可认为是Lambda表达式）上。

四大函数式接口实例：

/*
 * Java8 内置的四大核心函数式接口
 * <p>
 * Consumer<T> : 消费型接口
 * void accept(T t);
 * <p>
 * Supplier<T> : 供给型接口
 * T get();
 * <p>
 * Function<T,R> : 函数型接口
 * R apply(T t);
 * <p>
 * Predicate<T> : 断言型接口
 * boolean test(T t);
 */
public class TestLambda {

    //Consumer<T> 消费型接口 :
    @Test
    public void test1() {
        //使用Lambda表达式,调用Consumer接口,实现抽象方法accept().
        happy(10000, (money) -> System.out.println("用户每次消费" + money + "元"));
        //用户每次消费10000.0元
    }

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

    //Supplier<T> 供给型接口 :
    @Test
    public void test2() {
        //随机生成100以内的10个整数
        List<Integer> numList = getNumList(10, () -> (int) (Math.random() * 100));      //使用Lambda表达式实现接口方法
        System.out.println(numList.toString());
        //[40, 46, 15, 3, 67, 53, 62, 9, 98, 93]
    }

    //需求:产生指定个数的整数,并嵌入集合中.
    public List<Integer> getNumList(int num, Supplier<Integer> sup) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < num; i++) {
            Integer n = sup.get();
            list.add(n);
        }
        return list;
    }

    //Function<T,R> 函数型接口 :
    @Test
    public void test3() {
        //去除字符串str首尾空格
        String newStr = strHandler("\t\t\t Java8内置的四大核心函数式接口 \t\t", (str) -> str.trim());
        System.out.println(newStr);       //Java8内置的四大核心函数式接口
        String subStr = strHandler(newStr, s -> s.substring(8, 12));
        System.out.println(subStr);       //四大核心
    }

    //需求:用于处理字符串
    public String strHandler(String str, Function<String, String> fun) {
        return fun.apply(str);
    }

    //Predicate<T> 断言型接口 :

    @Test
    public void test4() {
        List<String> list = Arrays.asList("Hello", "Java", "Lambda", "Day");
        List<String> res = filterStr(list, s -> s.length() > 3);        //筛选所有长度大于3的字符串
        System.out.println(res.toString());         //[Hello, Java, Lambda]
    }

    //需求: 将满足要求的字符串放入集合中
    public List<String> filterStr(List<String> list, Predicate<String> pre) {
        List<String> strList = new ArrayList<>();
        for (String str : list) {
            if (pre.test(str)) {
                strList.add(str);
            }
        }
        return strList;
    }
}

有人可能就会疑惑，这样写的意义何在？

        java是面向对象的，但是为了写起来方便，需要向一个方法传递一个方法，但是实际上并不能传递方法，而是传递了只有一个抽象方法的接口的实现类的对象，这样就做到类似传递方法了，其实Lambda表达式 就是一个对象。

        配合Lambda表达式调用函数式接口去处理数据，省去了很多实现类。当然，这样不仅让代码更加简洁，同时这样的一种思维也是比较贴合一些设计模式的，而且这样让你的代码更具有灵活性。

其他函数式接口：

上文介绍了四大函数式接口，但Java中肯定也不止有这些，下图举出其他的一些比较常用的函数式接口。