Java Stream 的 Collectors.toMap高级应用与最佳实践

// 基础形式：keyMapper 和 valueMapper
public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(
    Function<? super T, ? extends K> keyMapper,
    Function<? super T, ? extends U> valueMapper)
// 带合并函数的形式：处理键冲突
public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(
    Function<? super T, ? extends K> keyMapper,
    Function<? super T, ? extends U> valueMapper,
    BinaryOperator<U> mergeFunction)
// 带合并函数和 Map 工厂的形式：指定 Map 实现类型
public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(
    Function<? super T, ? extends K> keyMapper,
    Function<? super T, ? extends U> valueMapper,
    BinaryOperator<U> mergeFunction,
    Supplier<M> mapSupplier)

class Person {
    private String id;
    private String name;
    // 构造器、getter 略
}
List<Person> people = Arrays.asList(
    new Person("1", "Alice"),
    new Person("2", "Bob"),
    new Person("2", "Charlie")  // 重复键
);
// 保留最后出现的值
Map<String, String> idToName = people.stream()
    .collect(Collectors.toMap(
        Person::getId,          // key：ID
        Person::getName,        // value：姓名
        (existing, replacement) -> replacement  // 合并函数：保留新值
    ));
// 输出：{1=Alice, 2=Charlie}

// 将重复键的值合并为列表
Map<String, List<String>> idToNames = people.stream()
    .collect(Collectors.toMap(
        Person::getId,
        p -> Collections.singletonList(p.getName()),  // 单个值转为列表
        (list1, list2) -> {
            List<String> merged = new ArrayList<>(list1);
            merged.addAll(list2);
            return merged;
        }  // 合并函数：合并两个列表
    ));
// 输出：{1=[Alice], 2=[Bob, Charlie]}

Map<String, String> orderedMap = people.stream()
    .collect(Collectors.toMap(
        Person::getId,
        Person::getName,
        (existing, replacement) -> replacement,  // 合并函数
        LinkedHashMap::new  // 指定 Map 实现
    ));

Map<Integer, String> sortedMap = Stream.of(
    new AbstractMap.SimpleEntry<>(3, "C"),
    new AbstractMap.SimpleEntry<>(1, "A"),
    new AbstractMap.SimpleEntry<>(2, "B")
).collect(Collectors.toMap(
    Map.Entry::getKey,
    Map.Entry::getValue,
    (existing, replacement) -> existing,  // 合并函数（本例不会触发）
    TreeMap::new  // 指定 TreeMap
));
// 输出：{1=A, 2=B, 3=C}（按键排序）

Map<String, Integer> lengthMap = Stream.of("apple", null, "banana")
    .filter(Objects::nonNull)  // 过滤 null 元素
    .collect(Collectors.toMap(
        Function.identity(),
        String::length
    ));

Map<String, String> safeMap = people.stream()
    .collect(Collectors.toMap(
        Person::getId,
        p -> p.getName() != null ? p.getName() : "Unknown",  // 替换 null 值
        (existing, replacement) -> replacement
    ));

class UserStats {
    private int loginCount;
    private LocalDate lastLogin;
    public UserStats(int count, LocalDate date) {
        this.loginCount = count;
        this.lastLogin = date;
    }
    // getters, setters 略
}
Map<String, UserStats> userStatsMap = userActivityStream
    .collect(Collectors.toMap(
        UserActivity::getUserId,  // 键：用户ID
        activity -> new UserStats(  // 值：自定义对象
            1,                      // 初始登录次数
            activity.getLoginTime() // 最后登录时间
        ),
        (existing, newActivity) -> {  // 合并函数
            existing.setLoginCount(existing.getLoginCount() + 1);
            existing.setLastLogin(max(existing.getLastLogin(), newActivity.getLastLogin()));
            return existing;
        }
    ));

// 按部门分组，统计每个部门的员工姓名列表
Map<String, List<String>> employeesByDepartment = people.stream()
    .collect(Collectors.groupingBy(
        Person::getDepartment,
        Collectors.mapping(Person::getName, Collectors.toList())
    ));
// 使用 toMap 实现相同功能
Map<String, List<String>> employeesByDept = people.stream()
    .collect(Collectors.toMap(
        Person::getDepartment,
        p -> Collections.singletonList(p.getName()),
        (list1, list2) -> {
            List<String> merged = new ArrayList<>(list1);
            merged.addAll(list2);
            return merged;
        }
    ));

List<Map.Entry<String, Integer>> entries = Arrays.asList(
    new AbstractMap.SimpleEntry<>("A", 1),
    new AbstractMap.SimpleEntry<>("B", 2),
    new AbstractMap.SimpleEntry<>("C", 3)
);
// 将 Entry 流转换为 Map
Map<String, Integer> resultMap = entries.stream()
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        (existing, replacement) -> replacement  // 处理键冲突
    ));

// 低效：每次调用都计算 length()
Map<String, Integer> map = words.stream()
    .collect(Collectors.toMap(
        Function.identity(),
        String::length,
        (e, r) -> r
    ));
// 高效：使用 mapToEntry 预先计算
Map<String, Integer> optimizedMap = words.stream()
    .map(word -> new AbstractMap.SimpleEntry<>(word, word.length()))
    .collect(Collectors.toMap(
        Map.Entry::getKey,
        Map.Entry::getValue,
        (e, r) -> r
    ));

Map<KeyType, ValueType> map = stream.collect(
    Collectors.toMap(
        element -> element.getKey(),
        element -> element.getValue()
    )
);

.collect(Collectors.toMap(
    keyMapper,
    valueMapper,
    (existing, replacement) -> replacement  // 保留新值
))

.collect(Collectors.toMap(
    keyMapper,
    valueMapper,
    mergeFunction,
    LinkedHashMap::new  // 保持插入顺序
))

.filter(Objects::nonNull)  // 过滤 null 元素
.collect(Collectors.toMap(
    keyMapper,
    value -> value != null ? value : defaultValue
))