Java Lambda表达式 #

(参数列表) -> { 方法体 }

// 无参数
Runnable r1 = () -> { System.out.println("Hello"); };
Runnable r2 = () -> System.out.println("Hello");

// 单参数
Consumer<String> c1 = (s) -> System.out.println(s);
Consumer<String> c2 = s -> System.out.println(s);  // 省略括号

// 多参数
Comparator<Integer> comp1 = (a, b) -> { return a - b; };
Comparator<Integer> comp2 = (a, b) -> a - b;  // 省略return和大括号

// 指定参数类型
Comparator<Integer> comp3 = (Integer a, Integer b) -> a - b;

@FunctionalInterface
public interface Calculator {
    int calculate(int a, int b);
}

// Lambda实现
Calculator add = (a, b) -> a + b;
System.out.println(add.calculate(10, 20));  // 30

Predicate<Integer> isEven = n -> n % 2 == 0;
System.out.println(isEven.test(4));  // true

// 组合使用
Predicate<Integer> isPositive = n -> n > 0;
Predicate<Integer> isEvenAndPositive = isEven.and(isPositive);

Function<String, Integer> toLength = s -> s.length();
System.out.println(toLength.apply("Hello"));  // 5

// 组合使用
Function<String, String> upper = s -> s.toUpperCase();
Function<String, String> trim = s -> s.trim();
Function<String, String> upperAndTrim = upper.compose(trim);

Consumer<String> print = s -> System.out.println(s);
print.accept("Hello");

// 组合使用
Consumer<String> printUpper = s -> System.out.println(s.toUpperCase());
Consumer<String> printAndUpper = print.andThen(printUpper);

Supplier<Double> random = () -> Math.random();
System.out.println(random.get());

Supplier<String> supplier = () -> "Hello";

BinaryOperator<Integer> add = (a, b) -> a + b;
System.out.println(add.apply(10, 20));  // 30

BinaryOperator<Integer> max = BinaryOperator.maxBy(Integer::compare);
System.out.println(max.apply(10, 20));  // 20

IntPredicate intPredicate = n -> n > 0;
IntFunction<String> intFunction = n -> String.valueOf(n);
IntConsumer intConsumer = n -> System.out.println(n);
IntSupplier intSupplier = () -> 100;
IntBinaryOperator intBinaryOperator = (a, b) -> a + b;

// Lambda
Function<String, Integer> parser1 = s -> Integer.parseInt(s);

// 方法引用
Function<String, Integer> parser2 = Integer::parseInt;

// Lambda
Consumer<String> printer1 = s -> System.out.println(s);

// 方法引用
Consumer<String> printer2 = System.out::println;

// 对象方法引用
String str = "Hello";
Supplier<Integer> length = str::length;

// Lambda
Supplier<List<String>> listSupplier1 = () -> new ArrayList<>();

// 方法引用
Supplier<List<String>> listSupplier2 = ArrayList::new;

// 带参数构造
Function<Integer, List<String>> listFactory = ArrayList::new;
List<String> list = listFactory.apply(10);

Function<Integer, String[]> arrayFactory = String[]::new;
String[] array = arrayFactory.apply(5);

List<String> names = Arrays.asList("Charlie", "Alice", "Bob");

// Lambda排序
names.sort((a, b) -> a.compareTo(b));

// 方法引用
names.sort(String::compareTo);

// 降序
names.sort(Comparator.reverseOrder());

List<String> names = Arrays.asList("A", "B", "C");

// Lambda遍历
names.forEach(name -> System.out.println(name));

// 方法引用
names.forEach(System.out::println);

// 传统方式
Thread t1 = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
});

// Lambda
Thread t2 = new Thread(() -> System.out.println("Hello"));

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 过滤偶数
List<Integer> evens = numbers.stream()
    .filter(n -> n % 2 == 0)
    .collect(Collectors.toList());

System.out.println(evens);  // [2, 4, 6, 8, 10]

public class Test {
    public void test() {
        // Lambda中的this指向外部类
        Runnable r1 = () -> System.out.println(this.getClass());
        
        // 匿名类中的this指向匿名类
        Runnable r2 = new Runnable() {
            @Override
            public void run() {
                System.out.println(this.getClass());
            }
        };
    }
}