一、函数式接口介绍

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

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

我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。同时 javadoc 也会包含一条声明，说明这个接口是一个函数式接口。

在java.util.function包下定义了Java 8 的丰富的函数式接口。

如何理解函数式接口

Java从诞生日起就是一直倡导“一切皆对象”，在Java里面面向对象(OOP)编程是一切。但是随着python、scala等语言的兴起和新技术的挑战，Java不得不做出调整以便支持更加广泛的技术要求，也即Java不但可以支持OOP还可以支持OOF（面向函数编程）

在函数式编程语言当中，函数被当做一等公民对待。在将函数作为一等公民的编程语言中，Lambda表达式的类型是函数。但是在Java8中，有所不同。在Java8中，Lambda表达式是对象，而不是函数，它们必须依附于一类特别的对象类型——函数式接口。

简单的说，在Java8中，Lambda表达式就是一个函数式接口的实例。这就是Lambda表达式和函数式接口的关系。也就是说，只要一个对象是函数式接口的实例，那么该对象就可以用Lambda表达式来表示。

所以以前用匿名实现类表示的现在都可以用Lambda表达式来写。

JDK 1.8 之前已有的函数式接口:

  • java.lang.Runnable
  • java.util.concurrent.Callable
  • java.security.PrivilegedAction
  • java.util.Comparator
  • java.io.FileFilter
  • java.nio.file.PathMatcher
  • java.lang.reflect.InvocationHandler
  • java.beans.PropertyChangeListener
  • java.awt.event.ActionListener
  • javax.swing.event.ChangeListener

JDK 1.8 新增加的函数接口：

  • java.util.function

二、函数式接口

1、函数式接口举例

img

自定义函数式接口

1
2
3
4
5
6
7
8
@FunctionalInterface
public interface MyInterface {
    void method1();
 
    default int method2(int i ){
        return i;
    }
}

函数式接口中使用泛型

1
2
3
4
@FunctionalInterface
public interface MyInterface<T> {
    public T getValue(T t);
}

2、Java 内置四大核心函数式接口

img

消费型接口 Consumer 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Test
public void test1(){
    happyTime(500, new Consumer<Double>() {
        @Override
        public void accept(Double aDouble) {
            System.out.println(aDouble);
        }
    });
 
    happyTime(500,money -> System.out.println(money));
}
 
public void happyTime(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
@Test
public void test2(){
    String str1 = getstr(new Supplier<String>() {
        @Override
        public String get() {
            return "北京";
        }
    });
    System.out.println(str1);
 
    String str2 = getstr( () -> "南京");
    System.out.println(str2);
}
 
public String getstr(Supplier<String> sup){
    return sup.get();
}

函数型接口 Function<T, R>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Test
public void test3(){
    String str1 = integerToString(new Integer(3), new Function<Integer, String>() {
        @Override
        public String apply(Integer integer) {
            return integer.toString();
        }
    });
    System.out.println(str1);
 
    String str2 = integerToString(new Integer(4), integer -> integer.toString());
    System.out.println(str2);
}
public String integerToString(Integer integer, Function<Integer,String> fun){
    return fun.apply(integer);
}

断定型接口 Predicate 

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
27
28
@Test
public void test4(){
    List<String> list= Arrays.asList("北京","南京","上海");
 
    List<String> filterStrs=filterString(list, new Predicate<String>() {
        @Override
        public boolean test(String s) {
            return s.contains("京");
        }
    });
    System.out.println(filterStrs);
    
 
    List<String> filterStrs1=filterString(list,s -> s.contains("京"));
    System.out.println(filterStrs1);
}
 
//根据给定的规则，过滤集合中的字符串，此规则由Predicate的方法决定
public List<String> filterString(List<String> list, Predicate<String> pre){
    ArrayList<String> filterList = new ArrayList<>();
 
    for(String s : list){
        if(pre.test(s)){
            filterList.add(s);
        }
    }
    return filterList;
}

3、其他接口

img