1
package com.example.hr;
2

3
import java.util.function.Consumer;
4
import java.util.function.Function;
5
import java.util.function.Predicate;
6
import java.util.function.Supplier;
7

8
public class InterfaceLambdaTraining {
9

10
    public static class Ra1 implements Runnable {
11
        @Override // 仅供案例一使用
12
        public void run() {
13
            System.out.println("普通方式");
14
        }
15
    }
16

17
    public static class Cs1 implements Consumer<String> {
18
        @Override // 仅供案例二使用
19
        public void accept(String text) {
20
            System.out.println(text);
21
        }
22
    }
23

24
    public static class Sp1 implements Supplier<String> {
25
        @Override // 仅供案例三使用
26
        public String get() {
27
            return "你好Supplier";
28
        }
29
    }
30

31
    public static String createMessage() {
32
        return "方法引用"; // 仅供案例三使用
33
    }
34

35
    public static class Fc1 implements Function<String, Integer> {
36
        @Override // 仅供案例四使用
37
        public Integer apply(String str) {
38
            return str.length();
39
        }
40
    }
41

42
    public static class Pd1 implements Predicate<String> {
43
        @Override // 仅供案例五
44
        public boolean test(String text) {
45
            return text.length() > 3;
46
        }
47
    }
48

49
    public static void main(String[] args) {
50
        // ===================== 案例一：Runnable 无参，无返回 =====================
51
        Runnable ra1 = new Ra1();
52
        ra1.run();
53

54
        Runnable ra2 = new Runnable() {
55
            @Override
56
            public void run() {
57
                System.out.println("匿名内部类");
58
            }
59
        };
60
        ra2.run();
61

62
        Runnable ra3 = () -> System.out.println("Lambda");
63
        ra3.run();
64

65
        // ===================== 案例二：Consumer 一个参数，无返回 =====================
66
        Consumer<String> cs1 = new Cs1();
67
        cs1.accept("普通方式");
68

69
        Consumer<String> cs2 = new Consumer<String>() {
70
            @Override
71
            public void accept(String text) {
72
                System.out.println(text);
73
            }
74
        };
75
        cs2.accept("匿名内部类");
76

77
        Consumer<String> cs3 = (a) -> System.out.println(a);
78
        cs3.accept("Lambda");
79

80
        Consumer<String> cs4 = System.out::println;
81
        cs4.accept("方法调用");
82

83
        // ===================== 案例三：Supplier 无参，有返回 =====================
84
        Supplier<String> sp1 = new Sp1();
85
        System.out.println(sp1.get());
86

87
        Supplier<String> sp2 = new Supplier<String>() {
88
            @Override
89
            public String get() {
90
                return "匿名内部类";
91
            }
92
        };
93
        System.out.println(sp2.get());
94

95
        Supplier<String> sp3 = () -> "Lambda";
96
        // 默认返回，也可以块包裹起来
97
        // Supplier<String> sp3=()->{
98
        //     return "Lambda";
99
        // };
100
        System.out.println(sp3.get());
101

102
        Supplier<String> sp4 = InterfaceLambdaTraining::createMessage;
103
        System.out.println(sp4.get());
104

105
        // ===================== 案例四：Function 一个参数，有返回 =====================
106
        Function<String, Integer> fc1 = new Fc1();
107
        System.out.println(fc1.apply("hello"));
108

109
        Function<String, Integer> fc2 = new Function<String, Integer>() {
110
            @Override
111
            public Integer apply(String str) {
112
                return str.length();
113
            }
114
        };
115
        System.out.println(fc2.apply("hello!"));
116

117
        Function<String, Integer> fc3 = (a) -> a.length();
118
        System.out.println(fc3.apply("hello!!"));
119

120
        Function<String, Integer> fc4 = String::length;
121
        System.out.println(fc4.apply("hello!!!"));
122

123
        // ===================== 案例五：Predicate 一个参数，返回boolean =====================
124
        Predicate<String> pd1 = new Pd1();
125
        System.out.println(pd1.test("hello"));
126

127
        Predicate<String> pd2 = new Predicate<String>() {
128
            @Override
129
            public boolean test(String text) {
130
                return text.length() > 3;
131
            }
132
        };
133

134
        Predicate<String> pd3 = (x) -> x.length() > 3;
135

136
        Predicate<String> pd4 = pd1::test;
137

138
        /*
139
         * 方法引用有4种：
140
         * 1. 对象::实例方法
141
         * 2. 类名::静态方法
142
         * 3. 类名::实例方法
143
         * 4. 类名::new
144
         *
145
         * 类名::实例方法比较特殊，第一个传入的参数，会自动作为调用这个实例方法的对象（比如String::length）
146
         */
147
    }
148
}