Java函数式编程：Lambda与Stream的魔法

// 传统方式：匿名内部类
Runnable oldRunnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};
// Lambda方式
Runnable lambdaRunnable = () -> System.out.println("Hello Lambda");

// 无参函数
() -> System.out.println("无参");
// 单参函数（可省略括号）
name -> System.out.println("Hello " + name);
// 多参函数
(x, y) -> x + y;
// 代码块
(name, age) -> {
    String info = name + ":" + age;
    return info;
};

@FunctionalInterface
interface TriFunction<T,U,V,R> {
    R apply(T t, U u, V v);
}
// 使用
TriFunction<Integer, Integer, Integer, Integer> sumThree = 
    (a, b, c) -> a + b + c;
int result = sumThree.apply(1, 2, 3); // 6

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// 1. 静态方法引用
names.forEach(System.out::println);
// 2. 实例方法引用
String prefix = "Name: ";
names.forEach(prefix::concat);
// 3. 任意对象方法引用
names.sort(String::compareToIgnoreCase);
// 4. 构造器引用
Supplier<List<String>> listSupplier = ArrayList::new;
List<String> newList = listSupplier.get();

List<Person> people = Arrays.asList(
    new Person("Alice", 25, "London"),
    new Person("Bob", 30, "New York"),
    new Person("Charlie", 20, "London")
);
// 流处理：找出伦敦居民的平均年龄
double averageAge = people.stream()
    .filter(p -> "London".equals(p.getCity())) // 过滤
    .mapToInt(Person::getAge)                 // 转换
    .average()                                // 聚合
    .orElse(0);                              // 默认值
System.out.println("伦敦居民平均年龄: " + averageAge);

// 按城市分组
Map<String, List<Person>> peopleByCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity));
// 按年龄分区（<30和>=30）
Map<Boolean, List<Person>> partitionByAge = people.stream()
    .collect(Collectors.partitioningBy(p -> p.getAge() < 30));

List<List<Integer>> numberLists = Arrays.asList(
    Arrays.asList(1, 2, 3),
    Arrays.asList(4, 5, 6),
    Arrays.asList(7, 8, 9)
);
// 扁平化为单个流
List<Integer> allNumbers = numberLists.stream()
    .flatMap(List::stream)
    .collect(Collectors.toList()); // [1,2,3,4,5,6,7,8,9]

// 收集为自定义对象
public class Statistics {
    private int count;
    private int sum;
    // 构造器/getter/setter
}
Statistics stats = people.stream()
    .mapToInt(Person::getAge)
    .collect(Statistics::new, 
             (s, age) -> { s.setCount(s.getCount()+1); s.setSum(s.getSum()+age); },
             (s1, s2) -> { s1.setCount(s1.getCount()+s2.getCount()); 
                            s1.setSum(s1.getSum()+s2.getSum()); });

long start = System.currentTimeMillis();
// 顺序流
long sequentialCount = IntStream.range(0, 1_000_000)
    .filter(n -> n % 3 == 0)
    .count();
// 并行流
long parallelCount = IntStream.range(0, 1_000_000)
    .parallel()               // 只需添加此调用
    .filter(n -> n % 3 == 0)
    .count();
System.out.println("顺序耗时: " + (System.currentTimeMillis()-start) + "ms");
System.out.println("并行耗时: " + (System.currentTimeMillis()-start) + "ms");

// 传统try-with-resources
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    // 使用资源
}
// 函数式增强
public static void useResource(Consumer<BufferedReader> consumer) {
    try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
        consumer.accept(br);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
// 使用
useResource(br -> {
    br.lines().forEach(System.out::println);
});

// 事件发布器
class EventBus {
    private Map<String, List<Consumer<Object>>> handlers = new HashMap<>();


    public void on(String eventType, Consumer<Object> handler) {
        handlers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(handler);
    }


    public void emit(String eventType, Object data) {
        handlers.getOrDefault(eventType, Collections.emptyList())
                .forEach(handler -> handler.accept(data));
    }
}
// 使用
EventBus bus = new EventBus();
bus.on("login", user -> System.out.println("用户登录: " + user));
bus.emit("login", "Alice");

// 错误：在lambda中修改外部状态
int[] counter = {0};
list.forEach(s -> counter[0]++);
// 正确：使用reduce
long count = list.stream().count();

// 优于 s -> s.length()
list.stream().map(String::length)

// 无终止操作，中间操作不会执行
Stream<String> stream = list.stream().filter(s -> {
    System.out.println("过滤: " + s); // 不会输出
    return s.length() > 3;
});

List<String> input = Arrays.asList("1", "2", "3");
// 转换为List<Integer> [1,2,3]

String text = "hello world hello java";
// 生成Map: {hello=2, world=1, java=1}

// 读取文件，找出长度>10的行，去重后排序
Files.lines(Paths.get("data.txt"))
     .filter(line -> line.length() > 10)
     .distinct()
     .sorted()
     .forEach(System.out::println);