函数式接口

有且只包含一个抽象方法的接口，称为函数式接口。

可以通过Lambda表达式来创建函数式接口的对象（只有函数式接口才能用Lambda表达式）。

可以使用@FunctionalInterface来声明是一个函数式接口。

常见的函数式接口：java.lang.Runnable、java.util.Comparator。

package com.morris.java8.lamdba;

public class RunnableExample {

    public static void main(String[] args) {

        // 匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " is running.");
            }
        }).start();

        // lamdba
        new Thread(() -> {
           System.out.println(Thread.currentThread().getName() + " is running.");
        }).start();

        // 进一步简化
        new Thread(() -> System.out.println(Thread.currentThread().getName() + " is running.")).start();

    }

}
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

JDK提供的函数式接口

java.util.function包中定义了大量的函数接口，下表列出了这些接口，并对其做一些简单的介绍。

函数式接口的使用

Predicate

package com.morris.java8.lamdba;

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

public class PredicatExample {

    public static void main(String[] args) {

        List<Integer> integerList = Arrays.asList(1, 3, 5, 4, 8, 9);

        List<Integer> result = filterEvenNumber(integerList, i -> i % 2 == 0);

        System.out.println(result);

    }

    public static List<Integer> filterEvenNumber(List<Integer> integerList, Predicate<Integer> predicate) {
        List<Integer> result = new ArrayList<>();
        for (Integer integer : integerList) {
            if(predicate.test(integer)) {
                result.add(integer);
            }
        }
        return result;
    }

}
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
29
30

Consumer

package com.morris.java8.lamdba;

import java.util.Arrays;
import java.util.List;

public class ComsumerExample {

    public static void main(String[] args) {
        List<Integer> integerList = Arrays.asList(1, 3, 5, 4, 8, 9);
        integerList.forEach(System.out::println);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

Function

package com.morris.java8.lamdba;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function;

public class FunctionExample {

    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("java", "hello", "world", "function");
        List<Integer> result = getLength(stringList, String::length);
        System.out.println(result);
    }

    public static List<Integer> getLength(List<String> stringList, Function<String, Integer> function) {
        List<Integer> integerList = new ArrayList<>();
        for (String s : stringList) {
            integerList.add(function.apply(s));
        }
        return integerList;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

函数式接口复合使用

Predicate复合

package com.morris.java8.lamdba;

import com.morris.java8.collector.Dish;

import java.nio.file.DirectoryStream;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class PredicateComplexExample {

    public static void main(String[] args) {

        List<Dish> dishList = Dish.createList();

        // 与-and
        // 找出卡路里>300的蔬菜
        Predicate<Dish> vegetablePredicate = Dish::isVegetarian;
        Predicate<Dish> moreThan300Predicate = d -> d.getCalories() >= 300;
        List<Dish> filter = filter(dishList, vegetablePredicate.and(moreThan300Predicate));
        System.out.println(filter);

        // 非-negate
        // 找出荤菜
        List<Dish> filter1 = filter(dishList, vegetablePredicate.negate());
        System.out.println(filter1);

        // 或-or
        // 找出卡路里大于300或者荤菜
        List<Dish> filter2 = filter(dishList, vegetablePredicate.or(moreThan300Predicate));
        System.out.println(filter2);

    }

    public static List<Dish> filter(List<Dish> dishList, Predicate<Dish> predicate) {
        List<Dish> result = new ArrayList<>();
        for (Dish dish : dishList) {
            if(predicate.test(dish)) {
                result.add(dish);
            }
        }
        return result;
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

Function复合

package com.morris.java8.lamdba;

import java.util.function.Function;

public class FunctionComplexExample {

    public static void main(String[] args) {

        // andThen
        Function<Integer, Integer> f = x -> x + 1; // f(x)
        Function<Integer, Integer> g = x -> x * 2; // g(x)
        Function<Integer, Integer> andThen =  f.andThen(g); // g(f)=g(f(x))

        Integer apply = andThen.apply(1);
        System.out.println(apply);

        // compose
        Function<Integer, Integer> y = x -> x + 1; // y(x)
        Function<Integer, Integer> z = x -> x * 2; // z(x)
        Function<Integer, Integer> compose =  y.compose(z); // y(z)=y(z(x))

        Integer apply2 = compose.apply(1);
        System.out.println(apply2);

    }
}
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