Map<Long, User> userObjMap = users.stream()
    .collect(Collectors.toMap(User::getId, Function.identity(), (u1, u2) -> u1));

Map<String, List<User>> groupByCity = users.stream()
    .collect(Collectors.groupingBy(User::getCity));

Map<String, Map<Integer, List<User>>> groupByCityAndAge =
    users.stream()
         .collect(Collectors.groupingBy(User::getCity,
                 Collectors.groupingBy(User::getAge)));

Map<String, Integer> totalScoreByCity = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.summingInt(User::getScore)
    ));

Map<String, Double> avgScoreByCity = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.averagingInt(User::getScore)
    ));

Map<Long, User> mergedById = users.stream()
    .collect(Collectors.toMap(
        User::getId,
        u -> new User(u.getId(), u.getName(), u.getCity(), u.getAge(), u.getScore()),
        (u1, u2) -> {
            u1.setScore(u1.getScore() + u2.getScore()); // 累加分数
            return u1;
        }
    ));

List<User> mergedList = new ArrayList<>(mergedById.values());

List<User> highScore = users.stream()
    .filter(u -> u.getScore() > 80)
    .collect(Collectors.toList());

List<User> beijingHighScore = users.stream()
    .filter(u -> "Beijing".equals(u.getCity()) && u.getScore() > 80)
    .collect(Collectors.toList());

List<User> sortedByScore = users.stream()
    .sorted(Comparator.comparing(User::getScore).reversed())
    .collect(Collectors.toList());

List<User> sorted = users.stream()
    .sorted(Comparator.comparing(User::getCity)
        .thenComparing(User::getScore, Comparator.reverseOrder()))
    .collect(Collectors.toList());

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

List<String> flatList = nested.stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());

boolean exists = users.stream().anyMatch(u -> u.getScore() == 100);

boolean allPass = users.stream().allMatch(u -> u.getScore() >= 60);

Map<String, IntSummaryStatistics> statsByCity = users.stream()
    .collect(Collectors.groupingBy(
        User::getCity,
        Collectors.summarizingInt(User::getScore)
    ));

IntSummaryStatistics beijingStats = statsByCity.get("Beijing");
// beijingStats.getSum() / getAverage() / getMax() / getMin()

List<User> page1 = users.stream()
    .skip(0) // 跳过 0 条
    .limit(2) // 取 2 条
    .collect(Collectors.toList());

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}

List<User> distinctUsers = users.stream()
    .filter(distinctByKey(User::getId))
    .collect(Collectors.toList());

List<String> result = users.parallelStream()
    .map(User::getName)
    .collect(Collectors.toList());