函数式接口

函数式接口是什么

有且只有一个抽象方法的接口被称为函数式接口（注意，任何被java.lang.Object实现的方法都不能视为抽象方法，例如 equals 和 toString方法），函数式接口适用于函数式编程的场景，Lambda就是Java中函数式编程的体现，可以使用Lambda表达式创建一个函数式接口的对象，一定要确保接口中有且只有一个抽象方法，这样Lambda才能顺利的进行推导。

@FunctionalInterface注解

与@Override 注解的作用类似，Java 8中专门为函数式接口引入了一个新的注解：@FunctionalInterface 。该注解可用于一个接口的定义上,一旦使用该注解来定义接口，编译器将会强制检查该接口是否确实有且仅有一个抽象方法，否则将会报错。但是这个注解不是必须的，只要符合函数式接口的定义，那么这个接口就是函数式接口。（但从代码编写规范考虑，最好加上该注解）

static方法和default方法

static方法：

java8中为接口新增了一项功能，定义一个或者多个静态方法。用法和普通的static方法一样,例如：

1
2
3
4
5
6
7
8
public interface Interface {
    /**
     * 静态方法
     */
    static void staticMethod() {
        System.out.println("static method");
    }
}

注意:实现接口的类或者子接口不会继承接口中的静态方法。

default方法：

java8在接口中新增default方法，是为了在现有的类库中中新增功能而不影响他们的实现类，试想一下，如果不增加默认实现的话，接口的所有实现类都要实现一遍这个方法，这会出现兼容性问题，如果定义了默认实现的话，那么实现类直接调用就可以了，并不需要实现这个方法。default方法怎么定义？

1
2
3
4
5
6
7
8
public interface Interface {
    /**
     * default方法
     */
    default void print() {
        System.out.println("hello default");
    }
}

注意：如果接口中的默认方法不能满足某个实现类需要，那么实现类可以覆盖默认方法。不用加default关键字，例如：

1
2
3
4
5
6
public class InterfaceImpl implements Interface {
    @Override
    public  void print() {
        System.out.println("hello default 2");
    }
}

在函数式接口的定义中是只允许有一个抽象方法，但是可以有多个static方法和default方法。

自定义函数式接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@FunctionalInterface
public interface JobFuntion {
 
    void execute();
 
}

public class Java8Characteristic {
    @Test
    public void stream() {
        //jdk8之前
        testJobFunction(new JobFuntion() {
            @Override
            public void execute() {
                System.out.println("我是自定义函数接口");
            }
        });
        //使用lambada表达式 代码更简洁
        testJobFunction(() -> System.out.println("我是自定义函数接口"));
    }
 
 
    private void testJobFunction(JobFuntion jobFuntion) {
        jobFuntion.execute();
    }
}

java8中内置的四大核心函数式接口

Consumer：消费型接口

void accept(T t)

1
2
3
4
//Consumer<T> 消费型接口
   public void happy(double money, Consumer<Double> con){
       con.accept(money);
   }

Supplier：供给型接口

T get();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//Supplier<T> 供给型接口
    //需求：产生一些整数，并放入集合中
    public List<Integer> getNumList(int num, Supplier<Integer> sup){
        List<Integer> list = new ArrayList<>();

        for (int i = 0; i < num; i++){
            Integer n = sup.get();
            list.add(n);
        }
        return list;
    }

    @Test
    public void test2(){
        List<Integer> numList = getNumList(10, () -> (int)(Math.random() * 100));

        for (Integer num : numList){
            System.out.println(num);
        }
    }

Function<T, R>：函数型接口

R apply(T t);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//Function<T, R> 函数型接口
    //需求：用于处理字符串
    public String strHandler(String str, Function<String, String> fun){
        return fun.apply(str);
    }

    @Test
    public void test3(){
        String newStr = strHandler("\t\t\t e路纵横开发团队", (str) -> str.trim());
        System.out.println(newStr);

        String subStr = strHandler("e路纵横开发团队", (str) -> str.substring(0, 4));
        System.out.println(subStr);
    }

Predicate：断言型接口

boolean test(T t);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//Predicate<T> 断言型接口
    //需求：将满足条件的字符串，放入集合中去
    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;
    }

    @Test
    public void test4(){
        List<String> list = Arrays.asList("Hello", "e路纵横", "Lambda", "ok");
        List<String> strList = filterStr(list, (s) -> s.length() > 3);

        for (String str : strList){
            System.out.println(str);
        }
    }