JavaのCollectors.toMapで重複キーが発生した時のマージ方法を解説する記事のアイキャッチ。

実装・エラー解決

JavaのCollectors.toMapでDuplicate keyを直す|重複時の選び方

この記事でわかること

Collectors.toMapは、異なる要素から同じキーが作られると、標準ではIllegalStateExceptionを投げます。第3引数へマージ関数を渡せば回避できますが、機械的に先勝ち・後勝ちへするとデータ欠落を隠す危険があります。キーが本当に一意か、重複時にどちらを採用するか、複数件を残すべきかを業務仕様から決めます。1キーに複数値が正しいならgroupingByを使います。

新人SE
新人SE
StreamをMapへ変えただけなのに、Duplicate keyで本番データだけ落ちました。第3引数を足せば終わりですか?
ポンコツSE
ポンコツSE
例外は直せますが、どちらのデータを残すかを決めないままマージすると、今度は静かにデータを捨てます。先に業務上の一意性を確認します。

Collectors.toMapは一覧をMapへ変換できる便利なCollectorです。しかし、開発用データが一意だっただけで「キーは重複しない」と思い込み、本番や結合テストでIllegalStateException: Duplicate keyに遭遇するケースがあります。

重要なのは例外を消すことではありません。重複は異常なのか、先の値を残すのか、後の値で更新するのか、複数件を保持するのかを決めることです。

この記事のポイント

  • toMapは同じキーが来ると標準では例外になる
  • 第3引数のマージ関数で重複時の処理を指定できる
  • 先勝ち・後勝ちは業務仕様を確認して選ぶ
  • 重複が異常なら例外のまま明示的に止める
  • 1キー複数値ならgroupingByを使う

XのJavaクイズでDuplicate keyを確認する

A、B、AのListをCollectors.toMapでMapへ変換できるかを問うJavaクイズ画像。
同じキーAが2回来る場合、このMapは作れるでしょうか。

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, Integer> lengthsWithoutMerge(List<String> values) {
        return Objects.requireNonNull(values, "values").stream()
                .collect(Collectors.toMap(value -> value, String::length));
    }

画像はXで出題した短い断片です。配布版では同じ変換をlengthsWithoutMergeへまとめ、T01からList.of("A", "B", "A")を渡します。Aの値はどちらも1ですが、キーが重複すれば例外になります。値が同じなら自動で1件へまとめる仕組みではありません。

答えは、重複キーAでIllegalStateExceptionです。標準のtoMapには、同じキーをどのようにまとめるかが指定されていないためです。

Collectors.toMapで重複キーAによりIllegalStateExceptionとなり、第3引数でマージ関数を指定できると説明する回答画像。
第3引数でマージできますが、残す値は業務仕様から決めます。

Xの出題ポストと回答ポストも参照できます。

toMapの3つの関数を理解する

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<Long, String> namesWithoutMerge(List<User> users) {
        return Objects.requireNonNull(users, "users").stream()
                .collect(Collectors.toMap(User::getId, User::getName));
    }

第1引数はキーを作る関数、第2引数は値を作る関数です。異なるUserから同じIDが作られた場合、Mapには同じキーを2つ入れられません。そこで重複時の処理を第3引数へ追加します。

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<Long, String> firstNamesById(List<User> users) {
        return Objects.requireNonNull(users, "users").stream()
                .collect(Collectors.toMap(
                        User::getId,
                        User::getName,
                        (existing, incoming) -> existing));
    }

この節のUserは数値IDと表示名を持つgetter型です。社員番号を扱う後のEmployeeとは別の型として定義しています。以下に全メソッド、import、型、ビルド設定の全文を置きます。抜粋だけを貼って未定義の型で止まらないよう、実行時はZIPの一式を使ってください。

クリックで全文を開く:User.java:数値IDと表示名
package info.syachiku.tomap;

import java.util.Objects;

/** 数値IDから表示名を引く例。社員番号の例にはEmployeeを使う。 */
public final class User {
    private final Long id;
    private final String name;

    public User(Long id, String name) {
        this.id = Objects.requireNonNull(id, "id");
        this.name = Objects.requireNonNull(name, "name");
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }
}
クリックで全文を開く:MapExamples.java:importと全変換メソッド
package info.syachiku.tomap;

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.stream.Collectors;

public final class MapExamples {
    private MapExamples() {
    }

    public static Map<String, Integer> lengthsWithoutMerge(List<String> values) {
        return Objects.requireNonNull(values, "values").stream()
                .collect(Collectors.toMap(value -> value, String::length));
    }

    public static Map<String, Integer> quantitiesWithoutMerge(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.toMap(OrderLine::productCode, OrderLine::quantity));
    }

    public static Map<String, Integer> firstQuantities(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.toMap(
                        OrderLine::productCode,
                        OrderLine::quantity,
                        (existing, incoming) -> existing));
    }

    public static Map<String, Integer> lastQuantities(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.toMap(
                        OrderLine::productCode,
                        OrderLine::quantity,
                        (existing, incoming) -> incoming));
    }

    public static Map<String, Integer> totalQuantities(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.toMap(
                        OrderLine::productCode,
                        OrderLine::quantity,
                        Integer::sum));
    }

    public static Map<String, List<OrderLine>> groupLines(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.groupingBy(
                        OrderLine::productCode,
                        LinkedHashMap::new,
                        Collectors.toList()));
    }

    public static Map<Long, String> namesWithoutMerge(List<User> users) {
        return Objects.requireNonNull(users, "users").stream()
                .collect(Collectors.toMap(User::getId, User::getName));
    }

    public static Map<Long, String> firstNamesById(List<User> users) {
        return Objects.requireNonNull(users, "users").stream()
                .collect(Collectors.toMap(
                        User::getId,
                        User::getName,
                        (existing, incoming) -> existing));
    }

    public static Map<String, Employee> toEmployeeMap(List<Employee> employees) {
        return Objects.requireNonNull(employees, "employees").stream()
                .collect(Collectors.toMap(
                        Employee::employeeNo,
                        Function.identity(),
                        (existing, incoming) -> {
                            throw new IllegalStateException(
                                    "社員番号が重複しています: " + existing.employeeNo());
                        }));
    }

    public static Map<String, List<Order>> ordersByCustomer(List<Order> orders) {
        return Objects.requireNonNull(orders, "orders").stream()
                .collect(Collectors.groupingBy(Order::customerId));
    }

    public static Map<String, Long> countByStatus(List<Order> orders) {
        return Objects.requireNonNull(orders, "orders").stream()
                .collect(Collectors.groupingBy(Order::status, Collectors.counting()));
    }

    public static Map<String, String> labelsInEncounterOrder(List<Item> items) {
        return Objects.requireNonNull(items, "items").stream()
                .collect(Collectors.toMap(
                        Item::code,
                        Item::label,
                        (existing, incoming) -> existing,
                        LinkedHashMap::new));
    }
}
クリックで全文を開く:pom.xml:Java/JUnit/プラグインの固定版
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>info.syachiku.samples</groupId><artifactId>tomap-duplicate-key-1865</artifactId><version>1.0.0</version>
  <properties><maven.compiler.release>17</maven.compiler.release><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding></properties>
  <dependencies><dependency><groupId>org.junit.jupiter</groupId><artifactId>junit-jupiter</artifactId><version>5.12.2</version><scope>test</scope></dependency></dependencies>
  <build><plugins>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-resources-plugin</artifactId><version>3.3.1</version></plugin>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-compiler-plugin</artifactId><version>3.14.0</version></plugin>
    <plugin><groupId>org.apache.maven.plugins</groupId><artifactId>maven-surefire-plugin</artifactId><version>3.5.3</version></plugin>
  </plugins></build>
</project>

existingはMapに先に入っていた値、incomingは後から来た値です。この例は先勝ちですが、変数名をleft、rightだけにすると意図が分かりにくいため、役割が伝わる名前にします。

重複時の4つの判断

ここからは、商品Aが2個、Bが1個、Aが3個の同じ3行で比較します。Aの2行が注文明細なら合計か全件保持、どちらか一方だけを採用すべき情報なら優先順位、本来一意のマスターなら停止というように、重複した理由から選びます。例外が出なくなっただけでは修正完了ではありません。

package info.syachiku.tomap;

import java.util.Objects;

public record OrderLine(String productCode, int quantity) {
    public OrderLine {
        Objects.requireNonNull(productCode, "productCode");
    }
}

src/main/java/info/syachiku/tomap/Main.javaからの抜粋です。

        List<OrderLine> lines = List.of(
                new OrderLine("A", 2),
                new OrderLine("B", 1),
                new OrderLine("A", 3));
採用する仕様実メソッド同じ入力の結果テスト
重複を許可しないquantitiesWithoutMergeIllegalStateExceptionT02
先を採用firstQuantitiesA=2、B=1T03
後を採用lastQuantitiesA=3、B=1T04
数量を加算totalQuantitiesA=5、B=1T05
明細を捨てないgroupLinesA=[2, 3]、B=[1]T06

先に来た値を残す

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, Integer> firstQuantities(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.toMap(
                        OrderLine::productCode,
                        OrderLine::quantity,
                        (existing, incoming) -> existing));
    }

入力順に優先度があり、先頭が正式値と決まっている場合に使います。順序を持たないSetや、取得順を指定していないDB結果では、「先」を業務上の優先順位として扱えません。この例は順序を持つListの逐次処理で確認します。

後に来た値で上書きする

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, Integer> lastQuantities(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.toMap(
                        OrderLine::productCode,
                        OrderLine::quantity,
                        (existing, incoming) -> incoming));
    }

更新日時で並べた後に最新値を残すなど、後勝ちの根拠がある場合に使います。単に例外を消すために後勝ちにすると、古いデータと新しいデータのどちらが残ったか説明できません。

値を合計・結合する

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, Integer> totalQuantities(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.toMap(
                        OrderLine::productCode,
                        OrderLine::quantity,
                        Integer::sum));
    }

同じ商品コードの数量を合計するなら、重複は異常ではなく集約条件です。金額の場合は丸めや税計算のタイミング、文字列結合なら区切りや順序も仕様に含めます。

重複を異常として止める

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, Employee> toEmployeeMap(List<Employee> employees) {
        return Objects.requireNonNull(employees, "employees").stream()
                .collect(Collectors.toMap(
                        Employee::employeeNo,
                        Function.identity(),
                        (existing, incoming) -> {
                            throw new IllegalStateException(
                                    "社員番号が重複しています: " + existing.employeeNo());
                        }));
    }

社員番号の例はEmployeeを使います。new Employee("E001", "A")とnew Employee("E001", "B")を渡すT13は、toEmployeeMapが社員番号が重複しています: E001で停止することを確認します。数値IDのUserへ社員番号を渡す例ではありません。

クリックで全文を開く:Employee.java:社員番号と名前
package info.syachiku.tomap;

import java.util.Objects;

/** 社員番号を一意にする例。User.getId()の例とは別の型。 */
public record Employee(String employeeNo, String name) {
    public Employee {
        Objects.requireNonNull(employeeNo, "employeeNo");
        Objects.requireNonNull(name, "name");
    }
}

社員番号や外部連携IDなど本来一意であるべき項目なら、曖昧にマージせず止める方が安全です。標準例外のメッセージだけで調査しづらい場合は、キーや入力元を含む業務向け例外へ変換します。ただし個人情報をメッセージへ出しすぎないでください。

複数件を残すならgroupingByを使う

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, List<Order>> ordersByCustomer(List<Order> orders) {
        return Objects.requireNonNull(orders, "orders").stream()
                .collect(Collectors.groupingBy(Order::customerId));
    }

T14では顧客C001の注文O001/O003を両方残すことを確認します。同じ数量3行を比較したい場合はgroupLinesを使います。Aは数量2と3の2行、Bは数量1の1行で、合計3行が欠落せず残ります。

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, List<OrderLine>> groupLines(List<OrderLine> lines) {
        return Objects.requireNonNull(lines, "lines").stream()
                .collect(Collectors.groupingBy(
                        OrderLine::productCode,
                        LinkedHashMap::new,
                        Collectors.toList()));
    }
クリックで全文を開く:Order.java:注文ID・顧客ID・状態
package info.syachiku.tomap;

import java.util.Objects;

public record Order(String orderId, String customerId, String status) {
    public Order {
        Objects.requireNonNull(orderId, "orderId");
        Objects.requireNonNull(customerId, "customerId");
        Objects.requireNonNull(status, "status");
    }
}

顧客1人に注文が複数あるのが正しいなら、Map<String, Order>へ無理に1件だけ入れる設計が間違っています。Map<String, List<Order>>で全件を残します。

件数だけ必要なら下流Collectorを使えます。

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, Long> countByStatus(List<Order> orders) {
        return Objects.requireNonNull(orders, "orders").stream()
                .collect(Collectors.groupingBy(Order::status, Collectors.counting()));
    }

Mapの順序が必要なら第4引数も指定する

src/main/java/info/syachiku/tomap/MapExamples.javaからの抜粋です。

    public static Map<String, String> labelsInEncounterOrder(List<Item> items) {
        return Objects.requireNonNull(items, "items").stream()
                .collect(Collectors.toMap(
                        Item::code,
                        Item::label,
                        (existing, incoming) -> existing,
                        LinkedHashMap::new));
    }
クリックで全文を開く:Item.java:表示順を確認するコードと表示名
package info.syachiku.tomap;

import java.util.Objects;

public record Item(String code, String label) {
    public Item {
        Objects.requireNonNull(code, "code");
        Objects.requireNonNull(label, "label");
    }
}

T16の入力はB-old、A、C、B-newです。キーの反復順はB/A/C、Bの値は先勝ちでB-oldです。値を残す規則と、キーを並べる規則は別にassertしています。T17では重複Bを処理しても最初の位置が末尾へ動かないことを確認します。

このサンプルは順序を持つList.stream()の逐次処理です。T07で入力を逆にすると、先勝ちはA=3、後勝ちはA=2へ入れ替わり、全件保持のAも[3, 2]になります。通常のtoMapのMap型・反復順は保証されません。labelsInEncounterOrderは第4引数、groupLinesはgroupingByのsupplierへLinkedHashMap::newを明示しています。並列処理や取得順未指定のDB結果へ、ここでの順序説明を無条件には適用しません。

帳票やCSVで入力順を維持する必要がある場合は、LinkedHashMapを指定します。通常のtoMapが返すMapの具体実装や順序へ依存したコードを書かないようにします。並び順が要件なら、テストでも順序を確認してください。

現場で起きる原因はキー設計にもある

  • 店舗コードだけをキーにしたが、実際は会社コードとの複合キーだった
  • 削除済みデータも検索対象に含まれていた
  • 大文字・小文字や前後空白を正規化すると同じキーになった
  • 履歴テーブルから最新1件へ絞らず全世代を取得した
  • テストデータには重複がなく、本番移行データにだけ存在した

toMapの修正だけでなく、Repositoryの検索条件、DBの一意制約、複合キー、削除フラグも確認します。「Java側でマージできたから問題なし」とすると、データ品質の異常を見逃します。

重複データを含むテストを書く

クリックで全文を開く:MapExamplesTest.java:20件のJUnit全文
package info.syachiku.tomap;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class MapExamplesTest {
    private static List<OrderLine> duplicateLines() {
        return List.of(new OrderLine("A", 2), new OrderLine("B", 1), new OrderLine("A", 3));
    }

    @Test
    void T01_同じ値でも同じキーが重複すれば例外になる() {
        assertThrows(IllegalStateException.class,
                () -> MapExamples.lengthsWithoutMerge(List.of("A", "B", "A")));
    }

    @Test
    void T02_マージなしの数量変換は重複キーで止まる() {
        assertThrows(IllegalStateException.class,
                () -> MapExamples.quantitiesWithoutMerge(duplicateLines()));
    }

    @Test
    void T03_先勝ちは入力で先の数量を残す() {
        Map<String, Integer> actual = MapExamples.firstQuantities(duplicateLines());
        assertEquals(Map.of("A", 2, "B", 1), actual);
    }

    @Test
    void T04_後勝ちは入力で後の数量を残す() {
        assertEquals(Map.of("A", 3, "B", 1), MapExamples.lastQuantities(duplicateLines()));
    }

    @Test
    void T05_同じ商品コードの数量を合計する() {
        assertEquals(Map.of("A", 5, "B", 1), MapExamples.totalQuantities(duplicateLines()));
    }

    @Test
    void T06_groupingByは同じキーの全行を残す() {
        Map<String, List<OrderLine>> actual = MapExamples.groupLines(duplicateLines());
        assertEquals(List.of(2, 3), actual.get("A").stream().map(OrderLine::quantity).toList());
        assertEquals(List.of(new OrderLine("B", 1)), actual.get("B"));
        assertEquals(3, actual.values().stream().mapToInt(List::size).sum());
    }

    @Test
    void T07_入力を逆順にすると先勝ちと後勝ちの結果も入れ替わる() {
        List<OrderLine> reversed = new ArrayList<>(duplicateLines());
        Collections.reverse(reversed);
        assertEquals(3, MapExamples.firstQuantities(reversed).get("A"));
        assertEquals(2, MapExamples.lastQuantities(reversed).get("A"));
        assertEquals(5, MapExamples.totalQuantities(reversed).get("A"));
        assertEquals(List.of(3, 2), MapExamples.groupLines(reversed).get("A").stream()
                .map(OrderLine::quantity).toList());
    }

    @Test
    void T08_空の入力はどの方針でも空Mapになる() {
        assertAll(
                () -> assertTrue(MapExamples.quantitiesWithoutMerge(List.of()).isEmpty()),
                () -> assertTrue(MapExamples.firstQuantities(List.of()).isEmpty()),
                () -> assertTrue(MapExamples.lastQuantities(List.of()).isEmpty()),
                () -> assertTrue(MapExamples.totalQuantities(List.of()).isEmpty()),
                () -> assertTrue(MapExamples.groupLines(List.of()).isEmpty()));
    }

    @Test
    void T09_数値IDが一意ならgetterのUserから名前を引ける() {
        assertEquals(Map.of(1L, "Alice", 2L, "Bob"), MapExamples.namesWithoutMerge(
                List.of(new User(2L, "Bob"), new User(1L, "Alice"))));
    }

    @Test
    void T10_数値IDの重複もマージ指定なしでは止まる() {
        assertThrows(IllegalStateException.class, () -> MapExamples.namesWithoutMerge(
                List.of(new User(1L, "old"), new User(1L, "new"))));
    }

    @Test
    void T11_数値IDの先勝ちは先の名前を残す() {
        assertEquals("old", MapExamples.firstNamesById(
                List.of(new User(1L, "old"), new User(1L, "new"))).get(1L));
    }

    @Test
    void T12_社員番号が一意ならEmployeeを保存できる() {
        Employee first = new Employee("E001", "Alice");
        Employee second = new Employee("E002", "Bob");
        assertEquals(Map.of("E001", first, "E002", second), MapExamples.toEmployeeMap(List.of(first, second)));
    }

    @Test
    void T13_社員番号の重複は業務向け例外で止める() {
        IllegalStateException actual = assertThrows(IllegalStateException.class,
                () -> MapExamples.toEmployeeMap(List.of(new Employee("E001", "A"), new Employee("E001", "B"))));
        assertEquals("社員番号が重複しています: E001", actual.getMessage());
    }

    @Test
    void T14_顧客ごとの注文を全件残す() {
        Order first = new Order("O001", "C001", "NEW");
        Order second = new Order("O002", "C002", "DONE");
        Order third = new Order("O003", "C001", "NEW");
        Map<String, List<Order>> actual = MapExamples.ordersByCustomer(List.of(first, second, third));
        assertEquals(List.of(first, third), actual.get("C001"));
        assertEquals(List.of(second), actual.get("C002"));
    }

    @Test
    void T15_状態別の件数だけを数えられる() {
        assertEquals(Map.of("NEW", 2L, "DONE", 1L), MapExamples.countByStatus(List.of(
                new Order("O001", "C001", "NEW"), new Order("O002", "C002", "DONE"),
                new Order("O003", "C001", "NEW"))));
    }

    @Test
    void T16_LinkedHashMapでキーが初めて登場した順を保つ() {
        Map<String, String> actual = MapExamples.labelsInEncounterOrder(List.of(
                new Item("B", "B-old"), new Item("A", "A"), new Item("C", "C"), new Item("B", "B-new")));
        assertEquals(List.of("B", "A", "C"), new ArrayList<>(actual.keySet()));
        assertEquals("B-old", actual.get("B"));
    }

    @Test
    void T17_同じラベルでもキーが重複した位置を末尾へ動かさない() {
        Map<String, String> actual = MapExamples.labelsInEncounterOrder(List.of(
                new Item("B", "same"), new Item("A", "A"), new Item("B", "same")));
        assertEquals(List.of("B", "A"), new ArrayList<>(actual.keySet()));
    }

    @Test
    void T18_nullの一覧は空一覧へ読み替えない() {
        assertThrows(NullPointerException.class, () -> MapExamples.firstQuantities(null));
    }

    @Test
    void T19_一覧中のnull行を許可しない() {
        List<OrderLine> lines = Arrays.asList(new OrderLine("A", 2), null);
        assertThrows(NullPointerException.class, () -> MapExamples.totalQuantities(lines));
    }

    @Test
    void T20_同名でも数値IDが違えば別のキーになる() {
        assertEquals(Map.of(1L, "same", 2L, "same"), MapExamples.namesWithoutMerge(
                List.of(new User(1L, "same"), new User(2L, "same"))));
    }
}
テスト入力と仕様確認する結果
T01〜T06同値重複も例外、同じ3行の5方式例外/A2/A3/A5/Aの2行を区別
T07〜T08逆順と空List先後の逆転、空は空Map
T09〜T13/T20Userの数値IDとEmployeeの社員番号同名別IDは保持、社員番号重複は明示的停止
T14〜T17顧客の全注文/状態件数/表示順O001とO003を保持、NEW2、B/A/C順
T18〜T19null List/null行このサンプルではNullPointerException

空の一覧は空Mapを返します。このサンプルは一覧自体のnullとnull行を許可せず、型のコンストラクタでも文字列フィールドとUserのIDのnullを拒否します。これはこの入力契約であり、Collectors全般のnullキー仕様を説明したものではありません。数量は小さい架空のint値です。整数overflowや金額の丸めを検証した例ではありません。

クリックで全文を開く:Main.java:同じ入力を5方式で比較する実行入口
package info.syachiku.tomap;

import java.util.List;

public final class Main {
    private Main() {
    }

    public static void main(String[] args) {
        List<OrderLine> lines = List.of(
                new OrderLine("A", 2),
                new OrderLine("B", 1),
                new OrderLine("A", 3));
        try {
            MapExamples.quantitiesWithoutMerge(lines);
        } catch (IllegalStateException exception) {
            System.out.println("withoutMerge=" + exception.getClass().getSimpleName());
        }
        System.out.println("first A=" + MapExamples.firstQuantities(lines).get("A"));
        System.out.println("last A=" + MapExamples.lastQuantities(lines).get("A"));
        System.out.println("sum A=" + MapExamples.totalQuantities(lines).get("A"));
        System.out.println("group A=" + MapExamples.groupLines(lines).get("A").stream()
                .map(OrderLine::quantity).toList());
        List<Item> items = List.of(
                new Item("B", "B-old"), new Item("A", "A"),
                new Item("C", "C"), new Item("B", "B-new"));
        System.out.println("label keys=" + MapExamples.labelsInEncounterOrder(items).keySet());
    }
}

ZIPのpom.xmlがある場所で、次を実行してください。Javaクラスの全文は上の枠をクリックすると開けます。

mvn clean test
java -cp target/classes info.syachiku.tomap.Main
withoutMerge=IllegalStateException
first A=2
last A=3
sum A=5
group A=[2, 3]
label keys=[B, A, C]

テストそのものが誤変更を検出することも確認しました。検証用コピーでfirstQuantitiesのマージ関数だけを(existing, incoming) -> incomingに変え、mvn test '-Dtest=MapExamplesTest#T03*'を実行すると、Aの数量がexpected 2 / actual 3で失敗します。原本の先勝ちは変更せず、原本とZIP展開先で全20件の成功を確認しています。READMEに同じ再現手順があります。

一意なデータだけのテストでは、マージ関数の意図を検証できません。重複する2件の値を変え、どちらが残るか、合計されるか、例外になるかを明示します。

現場レビューでよくある指摘

// レビューコメント例
重複時に先勝ちとしていますが、先を優先する業務根拠が分かりません。
入力順の保証と採用ルールを確認してください。

// レビューコメント例
顧客ごとに注文は複数存在するため、toMapで1件を捨てず
groupingByで全件を保持してください。

// レビューコメント例
本来一意な社員番号の重複をマージするとデータ不整合を隠します。
キーを含む例外で止め、データ側も調査したいです。

提出前のセルフチェック

  • キーが業務上本当に一意か確認したか
  • 複合キーが必要ではないか
  • 先勝ち・後勝ちの根拠を説明できるか
  • 順序が保証されているか
  • 重複が異常なら例外で止めているか
  • 複数件が正しいならgroupingByを使ったか
  • 重複データを含むテストを書いたか
  • DB検索条件や一意制約も確認したか

Streamとコレクションを実践的に学ぶ参考書

StreamのCollectorは短く書ける分、データの前提をコードへ明示する必要があります。実践編でコレクション操作を整理しておくと判断しやすくなります。

今回のMap<String, List<Order>>が「顧客ごとに複数の注文を残す」型だと読めない場合や、マージ関数がどの値を返しているか追いづらい場合は、『スッキリわかるJava入門 実践編 第5版』でコレクション・ジェネリクス・ラムダ式・Streamをつなげて学び直すと、このコードを自分で判断する土台になります。先勝ちを業務で採用してよいかは、本の構文知識とは別に入力順と要件を確認してください。

書籍「スッキリわかるJava入門 実践編 第5版」の表紙
商品画像:Amazon.co.jp
PR Java基礎学習後の若手向け

スッキリわかるJava入門 実践編 第5版

中山 清喬 (著), 株式会社フレアリンク (監修)

基礎文法の次に必要な、現場寄りのJava知識を補う。

コレクション、ジェネリクス、ラムダ式、ストリームなど、業務コードで出会いやすい機能を入門編の次に学べます。

  • Java基礎の次に何を学ぶか迷っている
  • コレクションやStreamを整理したい

当サイトはAmazonアソシエイト・プログラムの参加者です。価格・在庫・配送条件はAmazonでご確認ください。

この記事とあわせて読みたい

関連記事Javaのfor文とStreamの使い分け 短さだけでStreamを選ばず、処理内容から判断する基準を解説します。 記事を読む 関連記事HashMapで値が取れない原因はequalsかも Mapのキーとequals・hashCodeの関係を確認できます。 記事を読む 関連記事Setで重複削除できない原因をJavaで解説 重複判定をオブジェクト設計から見直す方法を解説します。 記事を読む

まとめ

Collectors.toMapは同じキーが来ると標準ではIllegalStateExceptionになります。第3引数でマージできますが、先勝ちや後勝ちを機械的に選ぶとデータ欠落を隠します。

キーの一意性、重複時の採用ルール、順序、DB側の制約を確認してください。1キーに複数値が正しいならgroupingByを使い、重複データを含むテストで仕様を固定しましょう。

-実装・エラー解決
-, ,