Java 新特性

(x, y) -> x + y
x -> x * 2
() -> System.out.println("hello")

// 写法冗长，明确创建了一个匿名内部类
// 编译后会生成一个新的 .class 文件
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
}).start();

// 极简写法，本质是 Runnable 的实现
// 底层通过 invokedynamic 动态生成
new Thread(() -> System.out.println("Hello")).start();

List<Integer> list = Arrays.asList(3, 1, 2);

// 匿名内部类
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2;
    }
});

// Lambda
Collections.sort(list, (o1, o2) -> o1 - o2);

// 普通 Lambda 写法
Function<String, Integer> f = s -> Integer.parseInt(s);

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

// 普通 Lambda 写法
BiFunction<String, String, Boolean> f =
        (a, b) -> a.equals(b);

// 方法引用写法
BiFunction<String, String, Boolean> f =
        String::equals;

// 普通 Lambda 写法
PrintStream ps = System.out;
Consumer<String> c = s -> ps.println(s);

// 方法引用写法
PrintStream ps = System.out;
Consumer<String> c = ps::println;

// 普通 Lambda 写法
Function<String, User> f = name -> new User(name);

// 方法引用写法
Function<String, User> f = User::new;

import java.util.*;
import java.util.stream.*;

public class StreamDemo {
    public static void main(String[] args) {
        List<List<String>> data = Arrays.asList(
                Arrays.asList("apple", "banana", "apple"),
                Arrays.asList("orange", "banana"),
                Arrays.asList("pear", "kiwi")
        );
        List<String> result = data.stream()
                // 1️⃣ flatMap：打平
                // [apple, banana, apple, orange, banana, pear, kiwi]
                .flatMap(Collection::stream)
                // 2️⃣ filter：长度 > 5
                // [banana, orange, banana]
                .filter(s -> s.length() > 5)
                // 3️⃣ map：转大写
                // [BANANA, ORANGE, BANANA]
                .map(String::toUpperCase)
                // 4️⃣ distinct：去重
                // [BANANA, ORANGE]
                .distinct()
                // 5️⃣ sorted：排序
                // [BANANA, ORANGE]
                .sorted()
                // 6️⃣ skip(1)：跳过第一个
                // [ORANGE]
                .skip(1)
                // 7️⃣ limit(2)：取前 2 个
                // [ORANGE]
                .limit(2)
                // 8️⃣ peek：查看
                .peek(s -> System.out.println("转大写后: " + s))
                // 终止操作
                .collect(Collectors.toList());
        // 最终结果
        // [ORANGE]
        System.out.println(result);
    }
}

import java.util.*;
import java.util.stream.*;
import static java.util.stream.Collectors.*;

public class StreamTerminalDemo {

    public static void main(String[] args) {

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6);

        // 1️⃣ forEach（遍历）
        list.stream()
                .forEach(n -> System.out.print(n + " "));
        // 输出: 1 2 3 4 5 6

        System.out.println();

        // 2️⃣ count（计数）
        long count = list.stream().count();
        System.out.println("count = " + count); // 6

        // 3️⃣ anyMatch / allMatch / noneMatch（匹配判断）
        boolean anyGreaterThan5 = list.stream().anyMatch(n -> n > 5);
        boolean allGreaterThan0 = list.stream().allMatch(n -> n > 0);
        boolean noneNegative = list.stream().noneMatch(n -> n < 0);

        System.out.println(anyGreaterThan5); // true
        System.out.println(allGreaterThan0); // true
        System.out.println(noneNegative);    // true

        // 4️⃣ findFirst / findAny（查找）
        Optional<Integer> first = list.stream().findFirst();
        Optional<Integer> any = list.parallelStream().findAny();

        System.out.println(first.get()); // 1
        System.out.println(any.get());   // 任意一个元素

        // 5️⃣ reduce（归约）
        int sum = list.stream().reduce(0, Integer::sum);
        System.out.println("sum = " + sum); // 21

        // 6️⃣ collect + groupingBy（分组：按奇偶）
        Map<String, List<Integer>> group =
                list.stream().collect(groupingBy(n -> n % 2 == 0 ? "even" : "odd"));
        System.out.println(group);
        // {even=[2,4,6], odd=[1,3,5]}

        // 7️⃣ partitioningBy（分区：大于3）
        Map<Boolean, List<Integer>> partition =
                list.stream().collect(partitioningBy(n -> n > 3));
        System.out.println(partition);
        // {false=[1,2,3], true=[4,5,6]}

        // 8️⃣ joining（拼接）
        String joined = list.stream()
                .map(String::valueOf)
                .collect(joining(","));
        System.out.println(joined); // 1,2,3,4,5,6

        // 9️⃣ summarizing（统计汇总）
        IntSummaryStatistics stats =
                list.stream().collect(summarizingInt(Integer::intValue));
        System.out.println(stats);
        // count=6, sum=21, min=1, average=3.5, max=6

        // 🔟 collectingAndThen（收集后再处理）
        Integer max = list.stream()
                .collect(collectingAndThen(maxBy(Integer::compareTo), Optional::get));
        System.out.println("max = " + max); // 6
    }
}

import java.util.stream.*;

public class InfiniteStreamDemo {
    public static void main(String[] args) {

        // 1️⃣ iterate：递增序列
        Stream.iterate(0, n -> n + 1)
                .limit(5)
                .forEach(System.out::println);
        // 输出：0 1 2 3 4

        // 2️⃣ generate：随机数
        Stream.generate(Math::random)
                .limit(3)
                .forEach(System.out::println);
        // 输出：3个随机小数
    }
}

import java.util.*;

public class OptionalDemo {
    static class User {
        String name;
        User(String name) { this.name = name; }
        public String toString() { return "User{name='" + name + "'}"; }
    }

    public static void main(String[] args) {
        List<User> list = Arrays.asList(new User("Tom"), new User("Jerry"));

        Optional<User> opt = list.stream()
                .filter(u -> u.name.equals("Alice"))
                .findFirst(); // 可能找不到 -> Optional.empty()

        opt.ifPresent(u -> System.out.println("找到了: " + u));

        User user = opt.orElse(new User("Default")); // 找不到就给默认值
        System.out.println("最终使用: " + user);
    }
}

import java.util.*;
import java.util.stream.*;

public class ParallelStreamDemo {
    public static void main(String[] args) {

        // ✅ 推荐：无共享可变状态 + 计算密集
        int sum = IntStream.rangeClosed(1, 1_000_000)
                .parallel()                  // 并行执行（ForkJoinPool）
                .map(x -> x * x)             // 计算密集
                .sum();                      // 并行安全的归约
        System.out.println("sum=" + sum);

        // ❌ 不推荐：共享可变集合（线程安全问题）
        List<Integer> bad = new ArrayList<>();
        IntStream.rangeClosed(1, 10_000)
                .parallel()
                .forEach(bad::add);          // 可能丢数据/越界/结果不稳定
        System.out.println("bad size=" + bad.size());
    }
}

optional.orElse(expensiveMethod());     // 总会执行
optional.orElseGet(() -> expensive());  // 只有为空才执行

optional
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .ifPresent(System.out::println);

// 1️⃣ 获取当前时间
LocalDate today = LocalDate.now();
LocalDateTime now = LocalDateTime.now();
Instant instantNow = Instant.now();

// 2️⃣ 创建指定日期时间
LocalDate date = LocalDate.of(2025, 3, 1);
LocalDateTime dateTime = LocalDateTime.of(2025, 3, 1, 10, 30);

// 3️⃣ 时间加减（不可变，会返回新对象）
LocalDate nextWeek = today.plusDays(7);
LocalDate lastMonth = today.minusMonths(1);

// 4️⃣ 时间比较
boolean isBefore = date.isBefore(today);
boolean isAfter = date.isAfter(today);

// 5️⃣ 计算时间差（Duration 适用于时间差）
Duration duration = Duration.between(
        LocalDateTime.of(2025, 3, 1, 10, 0),
        LocalDateTime.of(2025, 3, 1, 12, 30)
);
long minutes = duration.toMinutes();

// 6️⃣ 格式化和解析
DateTimeFormatter formatter =
        DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = now.format(formatter);
LocalDateTime parsed =
        LocalDateTime.parse("2025-03-01 10:30:00", formatter);

// 7️⃣ 时间戳转换（Instant ↔ LocalDateTime）
LocalDateTime fromInstant =
        LocalDateTime.ofInstant(instantNow, ZoneId.systemDefault());

import java.time.*;
import java.time.format.DateTimeFormatter;

LocalDateTime dbTime = LocalDateTime.parse("2026-02-16T10:00:00");

// 1) 解释为东八区（Asia/Shanghai 或你实际用的东8区 ZoneId）
ZonedDateTime chinaTime = dbTime.atZone(ZoneId.of("Asia/Shanghai"));

// 2) 转成西五区（两种写法：固定 -05:00 或具体地区时区）
// 固定西5
ZonedDateTime westFixed = chinaTime.withZoneSameInstant(ZoneOffset.ofHours(-5));
// 纽约时区（有夏令时）
ZonedDateTime newYork = chinaTime.withZoneSameInstant(ZoneId.of("America/New_York"));

// 3) 输出给前端（按你需要的格式）
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String out1 = westFixed.format(fmt);
String out2 = newYork.format(fmt);