Lambda 表达式

1import java.util.ArrayList;
2import java.util.Collections;
3import java.util.Comparator;
4import java.util.List;
5
6public class OldStyleSort {
7    public static void main(String[] args) {
8        List<String> names = new ArrayList<>();
9        names.add("Alice");
10        names.add("Bob");
11        names.add("Charlie");
12
13        // Old way: Anonymous Inner Class
14        Collections.sort(names, new Comparator<String>() {
15            @Override
16            public int compare(String s1, String s2) {
17                return Integer.compare(s1.length(), s2.length());
18            }
19        });
20
21        System.out.println(names);
22    }
23}

1import java.util.ArrayList;
2import java.util.Collections;
3import java.util.List;
4
5public class LambdaSort {
6    public static void main(String[] args) {
7        List<String> names = new ArrayList<>();
8        names.add("Alice");
9        names.add("Bob");
10        names.add("Charlie");
11
12        // New way: Lambda Expression
13        Collections.sort(names, (s1, s2) -> Integer.compare(s1.length(), s2.length()));
14
15        System.out.println(names);
16    }
17}

Code Example

1BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b;

Using a block-bodied lambda

1Runnable task = () -> {
2    System.out.println("Starting task...");
3    System.out.println("Task complete.");
4};

1import java.util.Comparator;
2
3public class LambdaSyntax {
4    public static void main(String[] args) {
5        // 1. Type inference with expression body (cleanest)
6        // Used for short, single-line logic
7        Comparator<Integer> ascending = (a, b) -> Integer.compare(a, b);
8
9        // 2. Explicit types (verbose but valid)
10        // Reversing the arguments to compare(b, a) reverses the order (descending)
11        Comparator<Integer> descending = (Integer a, Integer b) -> Integer.compare(b, a);
12
13        // 3. Block body (required for multiple statements)
14        // Used when logic is complex
15        // Runnable is a task that takes no args and returns void
16        Runnable task = () -> {
17            System.out.println("Starting task...");
18            System.out.println("Task complete.");
19        };
20
21        // Running the examples
22        System.out.println("Compare 10, 5: " + ascending.compare(10, 5));
23        task.run();
24    }
25}

1import java.util.Comparator;
2
3public class TargetTyping {
4    public static void execute(Runnable task) {
5        task.run();
6    }
7    
8    public static void main(String[] args) {
9        // Target Type: Runnable (run() takes no args, returns void)
10        // Lambda: Takes no args, returns void (println is void)
11        Runnable greeter = () -> System.out.println("Hello World");
12        
13        // Target Type: Comparator (compare() takes two args, returns int)
14        // Lambda: Takes two args, returns int
15        Comparator<String> lengthComparator = (s1, s2) -> Integer.compare(s1.length(), s2.length());
16
17        execute(greeter);
18        System.out.println("Comparison: " + lengthComparator.compare("Hi", "Hello"));
19    }
20}