Debian Codegraph @

framework/tests/all-systems/java8/lambda/Lambda.java

raw
1 // see also the test for Issue450
2 // Test file for lambda syntax
3
4 interface Supplier<R> {
5 R supply();
6 }
7
8 interface Function<T, R> {
9 R apply(T t);
10 }
11
12 interface Consumer<T> {
13 void consume(T t);
14 }
15
16 interface BiFunction<T, U, R> {
17 R apply(T t, U u);
18 }
19
20 interface Noop {
21 void noop();
22 }
23
24 class Lambda {
25
26 public static void consumeStr(String str) {}
27
28 Lambda(Consumer<String> consumer) {
29 consumer.consume("hello");
30 }
31
32 // No parameters; result is void
33 Noop f1 = () -> {};
34 // No parameters, expression body
35 Supplier<Integer> f2 = () -> 42;
36 // No parameters, expression body
37 // Supplier<Void> f3 = () -> null;
38 // No parameters, block body with return
39 Supplier<Integer> f4 =
40 () -> {
41 return 42;
42 };
43 Noop f5 =
44 () -> {
45 System.gc();
46 }; // No parameters, void block body
47
48 // Complex block body with returns
49 Supplier<Integer> f6 =
50 () -> {
51 if (true) {
52 return 12;
53 } else {
54 int result = 15;
55 for (int i = 1; i < 10; i++) {
56 result *= i;
57 }
58 // conditional expression
59 Consumer<String> consumer =
60 result > 100 ? Lambda::consumeStr : Lambda::consumeStr;
61 return result;
62 }
63 };
64
65 // Single declared-type parameter
66 Function<Integer, Integer> f7 = (Integer x) -> x + 1;
67 // Single declared-type parameter
68 Function<Integer, Integer> f9 =
69 (Integer x) -> {
70 return (Integer) x + 1;
71 };
72 // Single inferred-type parameter
73 Function<Integer, Integer> f10 = (x) -> x + 1;
74 // Parentheses optional for single inferred-type parameter
75 Function<Integer, Integer> f11 = x -> x + 1;
76
77 // Single declared-type parameter
78 Function<String, Integer> f12 = (String s) -> s.length();
79 // Single declared-type parameter
80 Consumer<Thread> f13 =
81 (Thread t) -> {
82 t.start();
83 };
84 // Single inferred-type parameter
85 Consumer<String> f14 = s -> s.length();
86 // Single inferred-type parameter
87 Consumer<Thread> f15 =
88 t -> {
89 t.start();
90 };
91
92 // Multiple declared-type parameters
93 BiFunction<Integer, Integer, Integer> f16 = (Integer x, final Integer y) -> x + y;
94 // Multiple inferred-type parameters
95 BiFunction<String, String, String> f18 = (x, y) -> x + y;
96 }