1
// JDK 8 之前
2
Runnable r1 = new Runnable() {
3
    @Override
4
    public void run() {
5
        System.out.println("running");
6
    }
7
};
8

9
// JDK 8+ 用 Lambda
10
Runnable r2 = () -> System.out.println("running");
11

12
// 对比 JS
13
const r3 = () => console.log("running");

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

1
@FunctionalInterface
2
public interface MyFunction {
3
    void apply();          // 唯一的抽象方法
4
    // 可以有默认方法、静态方法
5
    default void log() { System.out.println("logged"); }
6
}
7

8
MyFunction f = () -> System.out.println("hi");
9
f.apply();

1
public void method() {
2
    int base = 10;                      // effectively final
3
    Function<Integer, Integer> add = x -> x + base;
4
    add.apply(5);                       // 15
5

6
    // ❌ 修改 base 后 Lambda 就不能引用了
7
    // base = 20;                        // 编译报错
8
}

1
int[] counter = {0};
2
list.forEach(x -> counter[0]++);         // 修改数组元素不算改引用
3

4
AtomicInteger total = new AtomicInteger();
5
list.forEach(x -> total.addAndGet(x));

1
// 四种形式
2

3
// 1. 静态方法：ClassName::staticMethod
4
Function<String, Integer> f1 = Integer::parseInt;   // s -> Integer.parseInt(s)
5

6
// 2. 特定对象的实例方法：instance::method
7
String prefix = "LOG: ";
8
Consumer<String> c1 = prefix::concat;               // s -> prefix.concat(s)
9

10
// 3. 任意对象的实例方法：ClassName::method
11
Function<String, Integer> f2 = String::length;      // s -> s.length()
12
Consumer<String> c2 = System.out::println;          // s -> System.out.println(s)
13

14
// 4. 构造器：ClassName::new
15
Supplier<ArrayList<String>> s1 = ArrayList::new;    // () -> new ArrayList<>()
16
Function<String, String> f3 = String::new;          // s -> new String(s)

1
// Lambda
2
list.forEach(x -> System.out.println(x));
3
// 方法引用
4
list.forEach(System.out::println);
5

6
// Lambda
7
list.sort((a, b) -> a.compareTo(b));
8
// 方法引用
9
list.sort(Comparable::compareTo);

1
// JS 风格
2
const result = users
3
    .filter(u => u.age >= 18)
4
    .map(u => u.name)
5
    .sort()
6
    .slice(0, 10);
7

8
// Java Stream 风格
9
List<String> result = users.stream()
10
    .filter(u -> u.getAge() >= 18)
11
    .map(User::getName)
12
    .sorted()
13
    .limit(10)
14
    .toList();

1
import java.util.stream.*;
2

3
// 从集合
4
List<String> list = List.of("a", "b", "c");
5
Stream<String> s1 = list.stream();
6
Stream<String> s2 = list.parallelStream();     // 并行流
7

8
// 从数组
9
String[] arr = {"a", "b"};
10
Stream<String> s3 = Arrays.stream(arr);
11

12
// 从固定值
13
Stream<String> s4 = Stream.of("a", "b", "c");
14
Stream<Integer> s5 = Stream.of(1, 2, 3);
15

16
// 空流
17
Stream<String> s6 = Stream.empty();
18

19
// 数字流（避免装箱，性能高）
20
IntStream ints = IntStream.of(1, 2, 3);
21
IntStream range = IntStream.range(0, 10);       // 0~9
22
IntStream rangeClosed = IntStream.rangeClosed(1, 10);  // 1~10
23

24
// 无限流
25
Stream<Integer> iterate = Stream.iterate(0, n -> n + 2);   // 0, 2, 4, ...
26
Stream<Double> generate = Stream.generate(Math::random);
27

28
// 从文件（每行一个元素）
29
try (Stream<String> lines = Files.lines(Path.of("a.txt"))) {
30
    lines.forEach(System.out::println);
31
}

1
import java.util.Optional;
2

3
// 创建
4
Optional<String> present = Optional.of("hello");      // 值不能为 null
5
Optional<String> empty = Optional.empty();
6
Optional<String> nullable = Optional.ofNullable(null); // 值可以为 null
7

8
// 检查
9
present.isPresent();          // true
10
present.isEmpty();            // false（JDK 11+）
11

12
// 取值
13
String value = present.get();                            // 直接取，空则抛异常
14
String orElse = empty.orElse("default");                 // 空则返回默认值
15
String orElseGet = empty.orElseGet(() -> compute());     // 空则计算默认值（惰性）
16
String orElseThrow = empty.orElseThrow(() -> new RuntimeException("没找到"));
17

18
// 转换
19
Optional<Integer> length = present.map(String::length);
20
Optional<Integer> flat = present.flatMap(s -> Optional.of(s.length()));
21

22
// 消费
23
present.ifPresent(s -> System.out.println(s));
24
present.ifPresentOrElse(
25
    s -> System.out.println("有值：" + s),
26
    () -> System.out.println("没值")
27
);
28

29
// 过滤
30
Optional<String> filtered = present.filter(s -> s.length() > 3);
31

32
// 转 Stream
33
Stream<String> stream = present.stream();

1
// JS 可选链
2
const name = user?.profile?.name ?? 'Anonymous';
3

4
// Java Optional
5
String name = Optional.ofNullable(user)
6
    .map(User::getProfile)
7
    .map(Profile::getName)
8
    .orElse("Anonymous");

1
// 串行
2
long count = hugeList.stream().filter(this::expensiveCheck).count();
3

4
// 并行
5
long count = hugeList.parallelStream().filter(this::expensiveCheck).count();

1
class OrderAnalytics {
2
    constructor(orders) { this.orders = orders; }
3

4
    totalRevenue() {
5
        return this.orders
6
            .filter(o => o.paid)
7
            .reduce((sum, o) => sum + o.amount, 0);
8
    }
9

10
    countByCategory() {
11
        const map = {};
12
        this.orders.forEach(o => { map[o.category] = (map[o.category] ?? 0) + 1; });
13
        return Object.entries(map).sort((a, b) => b[1] - a[1]);
14
    }
15

16
    uniqueItems() {
17
        return [...new Set(this.orders.flatMap(o => o.items))].sort();
18
    }
19
}

1
// Lambda
2
Runnable r = () -> System.out.println("hi");
3
Function<String, Integer> f = s -> s.length();
4
Predicate<Integer> p = n -> n > 0;
5
Consumer<String> c = System.out::println;
6
Supplier<Double> s = Math::random;
7

8
// 四大函数式接口
9
Function<T, R>:  R apply(T)
10
Predicate<T>:    boolean test(T)
11
Consumer<T>:     void accept(T)
12
Supplier<T>:     T get()
13

14
// 组合
15
f1.andThen(f2)   // 先 f1 后 f2
16
f1.compose(f2)   // 先 f2 后 f1
17
p1.and(p2) / p1.or(p2) / p1.negate()
18

19
// 方法引用
20
Integer::parseInt        // 静态方法
21
System.out::println      // 实例方法
22
String::length           // 任意对象的实例方法
23
ArrayList::new           // 构造器
24

25
// Stream 三段式
26
list.stream()
27
    .filter(x -> x > 0)           // 中间：过滤
28
    .map(x -> x * 2)              // 中间：映射
29
    .flatMap(Collection::stream)  // 中间：扁平化
30
    .distinct()                   // 中间：去重
31
    .sorted(Comparator.reverseOrder())  // 中间：排序
32
    .limit(10).skip(5)            // 中间：切片
33
    .peek(System.out::println)    // 中间：窥视
34
    .collect(Collectors.toList()) // 终止：收集
35
    // .toList()                  // 终止：JDK 16+ 简写
36
    // .forEach(...)              // 终止：遍历
37
    // .count()                   // 终止：计数
38
    // .reduce(...)               // 终止：聚合
39
    // .anyMatch/allMatch/noneMatch
40
    // .findFirst/findAny
41

42
// Collectors 常用
43
toList() / toSet() / toUnmodifiableList()
44
toMap(k, v) / toMap(k, v, mergeFn)
45
joining(", ")
46
groupingBy(classifier)
47
groupingBy(classifier, counting())
48
groupingBy(classifier, summingDouble(...))
49
groupingBy(classifier, mapping(..., toList()))
50
partitioningBy(predicate)
51
maxBy(comparator) / minBy(comparator)
52

53
// 数字流
54
IntStream.range(0, 10).sum()
55
list.stream().mapToInt(X::getValue).average().orElse(0)
56

57
// Optional
58
Optional.of(x) / Optional.empty() / Optional.ofNullable(x)
59
opt.map(...).filter(...).orElse(default)
60
opt.ifPresent(...) / opt.ifPresentOrElse(a, b)
61

62
// 并行流（谨慎使用）
63
list.parallelStream()...