/** * ドメイン非依存URL出力フィルタ * javadrill.tech移行時はwp_options.home/siteurlのみ変更すればよい * * データベースには絶対URL（https://minner.asia）を保持し、 * 表示時に現在のドメイン（home_url()）に動的変換する */ function javadrill_make_urls_dynamic($content) { if (empty($content)) { return $content; } // データベース内の絶対URLを現在のhome_url()に置換 $old_url = 'https://minner.asia'; $new_url = untrailingslashit(home_url()); // http版も対応（念のため） $content = str_replace($old_url, $new_url, $content); $content = str_replace('http://minner.asia', $new_url, $content); return $content; } // 投稿本文、ウィジェット、タームの説明、抜粋に適用 add_filter('the_content', 'javadrill_make_urls_dynamic', 20); add_filter('widget_text', 'javadrill_make_urls_dynamic', 20); add_filter('term_description', 'javadrill_make_urls_dynamic', 20); add_filter('get_the_excerpt', 'javadrill_make_urls_dynamic', 20); 解答例 | Javaドリル https://minner.asia 楽々学べるJavaの問題集 Fri, 05 Sep 2025 01:56:00 +0000 ja hourly 1 https://wordpress.org/?v=6.8.3 https://minner.asia/wp-content/uploads/2023/10/cropped-logo-32x32.png 解答例 | Javaドリル https://minner.asia 32 32 102 「Map修羅道」 StepFinal　解答例 https://minner.asia/archives/5008 https://minner.asia/archives/5008#respond Mon, 19 May 2025 01:56:52 +0000 http://localhost/?p=5008
  1. MapUtil.java
    1. 解説：Mapを使って注文処理を実装する
      1. ポイントとなる処理
      2. 実行結果の例
      3. まとめ
    2. 🎯 実習で理解を深めよう

MapUtil.java

import java.util.*;

public class MapUtil {
    public static void runOrderSimulator() {
        // 商品ごとの単価を保持するMap
        Map<String, Integer> priceMap = new HashMap<>();
        priceMap.put("Apple", 120);
        priceMap.put("Banana", 80);
        priceMap.put("Orange", 100);

        // 注文数を保持するMap
        Map<String, Integer> orderMap = new HashMap<>();
        orderMap.put("Apple", 3);
        orderMap.put("Banana", 5);
        orderMap.put("Grape", 2); // 登録されていない商品

        int total = 0; // 総売上金額

        // 注文Mapをループ
        for (String product : orderMap.keySet()) {
            int quantity = orderMap.get(product);

            // 商品が登録されているかチェック
            if (priceMap.containsKey(product)) {
                int price = priceMap.get(product);
                int subtotal = price * quantity;

                // 明細を出力
                System.out.println(product + " → 単価: " + price + "円, 個数: " + quantity + ", 小計: " + subtotal + "円");

                // 総計に加算
                total += subtotal;
            } else {
                // 商品が見つからない場合はエラー表示
                System.out.println("エラー: 商品 '" + product + "' は未登録です。");
            }
        }

        // 総売上を出力
        System.out.println("総売上: " + total + "円");
    }
}

解説：Mapを使って注文処理を実装する

このステップでは、これまで学んだMap操作を総動員して、実践的な処理を構築します。

ポイントとなる処理

  1. 価格と注文数という「別のMap」を対応させる
    orderMap をループして、各商品名に対して priceMap で単価を参照します。
  2. containsKey() を使って、存在しない商品をチェック
    未登録商品（例：”Grape”）は、エラーとして出力し、集計対象に含めません。
  3. 各商品の小計（単価 × 数量）を計算し、逐次表示
    最後に総売上を合計・出力します。

実行結果の例

Apple → 単価: 120円, 個数: 3, 小計: 360円
Banana → 単価: 80円, 個数: 5, 小計: 400円
エラー: 商品 'Grape' は未登録です。
総売上: 760円

まとめ

  • Mapの組み合わせ（priceMap × orderMap）を自在に使えること
  • containsKey() による存在チェックの重要性
  • 条件分岐とループ処理の組み合わせが自然に書けるか

このFinalステップを自力で書き切れたなら、Mapの基本操作は一通りマスターしたと言って良い。
これでMapにビビることは、もうない。。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Just Keep Typing, Baby!
Map修羅道：StepFinal「商品注文シミュレータを完成させよ」
https://justkeeptyping.baby/archives/264

// tesh:
// 腑に落ちるまでが勉強。落としていけ、ここで。

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/5008/feed 0 102 「Map修羅道」 Step09　解答例 https://minner.asia/archives/5001 https://minner.asia/archives/5001#respond Mon, 19 May 2025 01:34:04 +0000 http://localhost/?p=5001
  1. MapUtil.java
    1. 解説：remove() と replace() はまったく違う
      1. 出力結果（例）
      2. 使い分けのポイント
      3. まとめ
    2. 🎯 実習で理解を深めよう

MapUtil.java

import java.util.*;

public class MapUtil {
    public static void testRemoveAndReplace() {
        // 会員番号と名前を管理するMapを作成
        Map<Integer, String> memberMap = new HashMap<>();

        // データを登録
        memberMap.put(1, "Yamada");
        memberMap.put(2, "Tanaka");
        memberMap.put(3, "Suzuki");

        // 登録後の出力
        System.out.println("=== 初期状態 ===");
        printMap(memberMap);

        // 会員番号2をremove
        memberMap.remove(2);

        // 削除後の出力
        System.out.println("=== remove後 ===");
        printMap(memberMap);

        // 会員番号3の名前をKatoにreplace
        memberMap.replace(3, "Kato");

        // 更新後の出力
        System.out.println("=== replace後 ===");
        printMap(memberMap);
    }

    // Mapの内容を出力するヘルパーメソッド
    private static void printMap(Map<Integer, String> map) {
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " → " + entry.getValue());
        }
    }
}

解説：remove() と replace() はまったく違う

Mapでデータを操作するとき、「値を消す」と「値を更新する」は別の操作です。
このステップではその違いを明確に体験します。

  1. Mapに次のデータを登録
    • 1 → “Yamada”
    • 2 → “Tanaka”
    • 3 → “Suzuki”
  2. remove(2) を実行すると、「キー2」とその値がMapから完全に消えます。
  3. replace(3, "Kato") を実行すると、「キー3」の値が “Suzuki” から “Kato” に上書きされます。

出力結果（例）

=== 初期状態 ===
1 → Yamada
2 → Tanaka
3 → Suzuki

=== remove後 ===
1 → Yamada
3 → Suzuki

=== replace後 ===
1 → Yamada
3 → Kato

使い分けのポイント

  • remove(key)：キーと値のペアごと削除する
  • replace(key, newValue)：値だけを更新（キーは残る）
  • 存在しないキーに対して replace をしても何も起きない

まとめ

Mapの操作には「削除」と「更新」があり、それぞれ明確に役割が違います。
データのライフサイクルを意識して使い分けましょう。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Just Keep Typing, Baby!
Map修羅道：Step09「削除と更新はぜんぜん違う」
https://justkeeptyping.baby/archives/261

// tesh:
// 正解だけじゃ、理解にはならん。こっちが本番。

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/5001/feed 0 102 「Map修羅道」 Step08　解答例 https://minner.asia/archives/4992 https://minner.asia/archives/4992#respond Mon, 19 May 2025 01:12:04 +0000 http://localhost/?p=4992
  1. MapUtil.java
    1. 解説：HashMapとnullの関係
    2. nullキーについて
    3. null値について
    4. 出力結果の例（順不同）
    5. まとめ：このステップで学ぶべきこと

MapUtil.java

import java.util.*;

public class MapUtil {
    public static void testNullBehavior() {
        // 会員IDと氏名を管理するMapを作成（HashMapはnullキー・null値を許容）
        Map<Integer, String> memberMap = new HashMap<>();

        // 通常のデータを登録
        memberMap.put(1001, "Yamada");

        // nullをキーとして登録（有効）
        memberMap.put(null, "Tanaka");

        // nullを値として登録（有効）
        memberMap.put(1002, null);

        // Mapの内容を出力
        for (Map.Entry<Integer, String> entry : memberMap.entrySet()) {
            Integer id = entry.getKey();
            String name = entry.getValue();
            System.out.println(id + " → " + name);
        }

        // nullキーで取得できるか確認
        System.out.println("nullキーの値: " + memberMap.get(null));

        // 値がnullのときの取得確認
        System.out.println("ID 1002 の値: " + memberMap.get(1002));
    }
}

解説：HashMapとnullの関係

JavaのHashMapは、他のMap実装と比べて柔軟で、nullをキーや値に許容します。

nullキーについて

map.put(null, "Tanaka");
  • HashMap は nullキーを1つだけ 登録できます
  • すでにnullキーがある状態で再度 put(null, ...) すると、上書きされます
  • TreeMap などでは nullキーは NullPointerException の原因になるので注意

null値について

map.put(1002, null);
  • null は 値として何個でも登録可能
  • ただし、null 値と「未登録」を区別するには containsKey() での存在確認が必要
map.containsKey(1002); // true（nullが登録されている）
map.get(1002);         // null（値がnull）
map.containsKey(9999); // false（未登録）

出力結果の例（順不同）

1001 → Yamada
null → Tanaka
1002 → null
nullキーの値: Tanaka
ID 1002 の値: null

まとめ：このステップで学ぶべきこと

  • HashMapはnullキーを1つ、null値を複数許可する
  • 値がnullなのか、未登録なのかは containsKey() で判別する
  • nullに関する仕様は Map実装ごとに違う ので要注意

Mapの柔軟さと落とし穴の両方を体験する重要なステップです。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Map修羅道：Step08　nullって登録していいの？ - Just Keep Typing, Baby!
→ javadrill.tech で出題された問題を見る（Step08）
justkeeptyping.baby

// tesh:
// 「意味はわからんけど通った」は一番キケン。確認しとけ。
]]> https://minner.asia/archives/4992/feed 0 102 「Map修羅道」 Step07　解答例 https://minner.asia/archives/4983 https://minner.asia/archives/4983#respond Mon, 19 May 2025 01:01:59 +0000 http://localhost/?p=4983
  1. MapUtil.java
    1. 解説：Mapの中にMap？ネスト構造の使い方
    2. 構造の意味
    3. データの登録方法
    4. 出力方法（2重ループ）
    5. 実行結果の例（順不同）
    6. まとめ：このステップで学ぶべきこと
    7. 🎯 実習で理解を深めよう

MapUtil.java

import java.util.*;

public class MapUtil {
    public static void printStoreInventory() {
        // 店舗別の商品在庫を記録するMap（ネストされたMap構造）
        // 外側のMap: 店舗名 → 内側のMap
        // 内側のMap: 商品名 → 在庫数
        Map<String, Map<String, Integer>> storeInventory = new HashMap<>();

        // --- データ登録（Tokyo店） ---
        addStock(storeInventory, "Tokyo", "Apple", 10);
        addStock(storeInventory, "Tokyo", "Banana", 5);

        // --- データ登録（Osaka店） ---
        addStock(storeInventory, "Osaka", "Apple", 7);
        addStock(storeInventory, "Osaka", "Orange", 3);

        // --- 出力 ---
        for (String store : storeInventory.keySet()) {
            System.out.println(store + ":");
            Map<String, Integer> products = storeInventory.get(store);
            for (String product : products.keySet()) {
                int stock = products.get(product);
                System.out.println("  " + product + " → " + stock);
            }
        }
    }

    // ヘルパーメソッド：商品在庫を追加する
    private static void addStock(Map<String, Map<String, Integer>> inventory,
                                 String store, String product, int stock) {
        // 店舗が存在しなければ新しくMapを作成
        if (!inventory.containsKey(store)) {
            inventory.put(store, new HashMap<>());
        }
        // 店舗に対応する商品Mapを取得し、商品と在庫を登録
        inventory.get(store).put(product, stock);
    }
}

解説：Mapの中にMap？ネスト構造の使い方

このステップでは、「Mapの中にMapが入る」というやや複雑な構造を扱います。
現実のデータ構造では非常によく使われる形です。

構造の意味

Map<String, Map<String, Integer>> storeInventory;
  • 外側のMap：キーは「店舗名」、値は「商品→在庫数」を管理するMap
  • 内側のMap：キーは「商品名」、値は「在庫数」

データの登録方法

if (!inventory.containsKey(store)) {
    inventory.put(store, new HashMap<>());
}
inventory.get(store).put(product, stock);
  • 店舗が初めて登場した場合、内側のMap（商品一覧）を新規作成
  • すでにある店舗には、商品と在庫を追加登録

出力方法（2重ループ）

for (String store : storeInventory.keySet()) {
    System.out.println(store + ":");
    for (String product : storeInventory.get(store).keySet()) {
        System.out.println("  " + product + " → " + 在庫数);
    }
}
  • 外側のMap（店舗）を回しながら
  • 内側のMap（商品）をさらに回して出力

実行結果の例（順不同）

Tokyo:
  Apple → 10
  Banana → 5
Osaka:
  Apple → 7
  Orange → 3

まとめ：このステップで学ぶべきこと

  • ネストされたMapの構造を作る方法（Map<String, Map<…>>）
  • 初期化の必要性と、ループ構造の正しい組み方
  • 現実的なデータ構造をJavaで扱う力を養う

このステップを理解すれば、複雑な階層構造のデータをJavaで自在に扱えるようになります。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Just Keep Typing, Baby!
Map修羅道：Step07「店舗別の商品在庫を管理せよ」
https://justkeeptyping.baby/archives/255

// tesh:
// 何かモヤっとしてる？ なら答えはここにある。

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/4983/feed 0 102 「Map修羅道」 Step06　解答例 https://minner.asia/archives/4975 https://minner.asia/archives/4975#respond Mon, 19 May 2025 00:47:06 +0000 http://localhost/?p=4975
  1. MapUtil.java
    1. 解説：「Mapは値で検索できない」ってどういうこと？
    2. なぜ苦手なのか？
    3. 書き方のポイント
    4. containsValue() では足りない理由
    5. 実行結果の例
    6. まとめ：このステップで学ぶべきこと
    7. 🎯 実習で理解を深めよう

MapUtil.java

import java.util.*;

public class MapUtil {
    public static void findProductIdByName() {
        // 商品IDと商品名の対応を記録するMapを作成
        Map<Integer, String> productMap = new HashMap<>();
        productMap.put(101, "Apple");
        productMap.put(102, "Banana");
        productMap.put(103, "Orange");

        // 検索対象の商品名
        String targetName = "Banana";

        // フラグと結果変数を用意
        boolean found = false;
        int foundId = -1;

        // Mapをループして、valueからkeyを探す
        for (Map.Entry<Integer, String> entry : productMap.entrySet()) {
            Integer id = entry.getKey();
            String name = entry.getValue();

            // 値（商品名）が一致したら
            if (name.equals(targetName)) {
                found = true;
                foundId = id;
                break; // 見つかったらループ終了
            }
        }

        // 結果の出力
        System.out.println("商品名: " + targetName);
        if (found) {
            System.out.println("商品ID: " + foundId);
        } else {
            System.out.println("見つかりませんでした");
        }
    }
}

解説：「Mapは値で検索できない」ってどういうこと？

Mapの基本は「キー → 値」です。
つまり、「IDから名前を引く」のは得意ですが、「名前からIDを探す」のは得意ではありません。

なぜ苦手なのか？

Mapはキーに対してハッシュテーブルやツリー構造を構築していますが、
値に関しては何のインデックスも持たないからです。

そのため、値からキーを探すには、全件ループして1件ずつ比較するしかありません。

書き方のポイント

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    if (entry.getValue().equals(target)) {
        // 一致したらentry.getKey()が目的のID
    }
}
  • equals() で文字列の比較
  • 見つかった時点で break すると効率が良い
  • 見つからなかった場合の処理も忘れずに

containsValue() では足りない理由

map.containsValue("Banana"); // true/false しか返さない
  • このメソッドでは 「値が存在するかどうか」 はわかるが、「どのキーか」 はわからない
  • 結局ループが必要になる

実行結果の例

商品名: Banana
商品ID: 102

まとめ：このステップで学ぶべきこと

  • Mapは「キーから値」は得意でも「値からキー」は苦手
  • 値からキーを探すには、全件ループして比較する必要がある
  • 検索効率を求めるなら「逆向きのMap」を別途用意する方法もある（応用）

このステップでMapの「片方向性」を知っておくことは、設計ミスを防ぐうえでとても重要です。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Just Keep Typing, Baby!
Map修羅道：Step06「この商品ID、何て名前？」
https://justkeeptyping.baby/archives/252

// tesh:
// このへん曖昧なままだと、痛い目みるぞ。

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/4975/feed 0 102 「Map修羅道」 Step05　解答例 https://minner.asia/archives/4967 https://minner.asia/archives/4967#respond Mon, 19 May 2025 00:25:52 +0000 http://localhost/?p=4967
  1. MapUtil.java
    1. 解説：Mapに順序を求めるときの注意点
      1. HashMap：順序なし（非決定的）
    2. まとめ：このステップで学ぶべきこと

MapUtil.java

import java.util.*;

public class MapUtil {
    public static void compareMapOrder() {
        // --- HashMapを使った場合 ---
        System.out.println("=== HashMap の出力 ===");

        // 順序が保証されないMap
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put("2023-05-03", "Curry");
        hashMap.put("2023-05-01", "Sushi");
        hashMap.put("2023-05-02", "Pasta");

        for (String date : hashMap.keySet()) {
            String menu = hashMap.get(date);
            System.out.println(date + " → " + menu);
        }

        // --- TreeMapを使った場合 ---
        System.out.println("=== TreeMap の出力 ===");

        // TreeMapにHashMapの内容を渡して変換
        Map<String, String> treeMap = new TreeMap<>(hashMap);

        for (String date : treeMap.keySet()) {
            String menu = treeMap.get(date);
            System.out.println(date + " → " + menu);
        }
    }
}

解説：Mapに順序を求めるときの注意点

JavaのMapにはいくつかの実装があります。
それぞれ順序の扱いが異なるため、出力の順番に意味がある場合は注意が必要です。

HashMap：順序なし（非決定的）

Map<String, String> map = new HashMap<>();
  • 要素の並び順は保証されない
  • 登録順にも、キーの大小にも関係ない
  • 出力結果は実行のたびに変わる可能性あり（内部のハッシュテーブル次第）

TreeMap：キーの自然順（昇順）

Map<String, String> map = new TreeMap<>(hashMap);
  • キーの順序に従って自動で並び替えて保持
  • 文字列なら辞書順、数値なら昇順になる
  • new TreeMap<>(hashMap) のように変換も可能

実行結果の例（順不同・ただしTreeMapは昇順で固定）

=== HashMap の出力 ===
2023-05-03 → Curry
2023-05-01 → Sushi
2023-05-02 → Pasta

=== TreeMap の出力 ===
2023-05-01 → Sushi
2023-05-02 → Pasta
2023-05-03 → Curry

まとめ：このステップで学ぶべきこと

  • HashMapは順序を持たない
  • TreeMapはキーの昇順で保持される
  • 順序が重要な場合はMapの種類を選ぶ必要がある

出力の順序でロジックが変わる場面では、Mapの選定がバグを防ぐ鍵になります。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Map修羅道：Step05　Mapの出力順に意味はあるか？ - Just Keep Typing, Baby!
→ javadrill.tech で出題された問題を見る（Step05）
justkeeptyping.baby

// tesh:
// これ、わかってないと次で爆死する。今、拾っとけ。
]]> https://minner.asia/archives/4967/feed 0 102 「Map修羅道」 Step04　解答例 https://minner.asia/archives/4960 https://minner.asia/archives/4960#respond Mon, 19 May 2025 00:16:39 +0000 http://localhost/?p=4960
  1. MapUtil.java
    1. 解説：Mapを使って「数える」
      1. 処理の流れ
      2. containsKey() を使う理由
      3. getOrDefault() を使った別解（参考）
    2. まとめ：このステップで学ぶべきこと
    3. 🎯 実習で理解を深めよう

MapUtil.java

import java.util.*;

public class MapUtil {
    public static void countOrders() {
        // 注文された商品リスト（重複あり）
        List<String> orders = Arrays.asList(
            "apple", "banana", "apple", "orange", "banana", "apple"
        );

        // 商品ごとのカウントを保持するMapを作成
        Map<String, Integer> countMap = new HashMap<>();

        // 注文リストを1件ずつ処理
        for (String item : orders) {
            // すでにその商品がMapにあれば、値を1増やす
            if (countMap.containsKey(item)) {
                int currentCount = countMap.get(item); // 現在のカウントを取得
                countMap.put(item, currentCount + 1);   // 1増やして再登録
            } else {
                // 初めて出現した商品 → 1を登録
                countMap.put(item, 1);
            }
        }

        // 結果を出力（出現回数を表示）
        for (Map.Entry<String, Integer> entry : countMap.entrySet()) {
            System.out.println(entry.getKey() + " → " + entry.getValue());
        }
    }
}

解説：Mapを使って「数える」

このステップでは、Mapを使った出現回数の集計という定番パターンを学びます。

処理の流れ

  1. 重複を含むリスト（List<String>）を用意する
  2. Map<String, Integer> を使ってカウントを保持する
  3. for ループで1件ずつ処理し、
  • すでに登録されている場合：値を +1
  • はじめてのキー：値を 1 で初期化
  1. 最終的に、商品ごとの出現回数を表示する

containsKey() を使う理由

カウント処理では、まずそのキーがすでにMapにあるかを確認しないといけません。
ない場合は null を返すので、いきなり get() して +1 しようとすると NullPointerException が出る可能性があります。

getOrDefault() を使った別解（参考）

int count = countMap.getOrDefault(item, 0);
countMap.put(item, count + 1);
  • getOrDefault(key, defaultValue) は、キーが存在しない場合に defaultValue を返してくれる便利メソッドです。
  • Java8以降で利用可能（初学者には最初は明示的な containsKey() の方がわかりやすい）

実行結果の例（順不同）：

apple → 3
banana → 2
orange → 1

まとめ：このステップで学ぶべきこと

  • 値の型が Integer になっても、Mapの基本操作は同じ
  • 集計処理の定石：「存在確認 → 加算 or 初期化」
  • 出現回数カウントは実務でもよく使われる重要パターン

このステップをきっちり理解できれば、Mapでの情報集約処理がグッと楽になります。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Just Keep Typing, Baby!
Map修羅道：Step04「出現回数をカウントせよ」
https://justkeeptyping.baby/archives/246

// tesh:
// 「まぁ動いたしいいか」って逃げる前に。これ読んで。

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/4960/feed 0 102 「Map修羅道」 Step03　解答例 https://minner.asia/archives/4951 https://minner.asia/archives/4951#respond Mon, 19 May 2025 00:06:24 +0000 http://localhost/?p=4951
  1. MapUtil.java
    1. 解説：Mapに複数の値を格納したいときは List を使え
      1. なぜ Map<String, List<String>> が必要なのか？
      2. 実装のポイント：キーの存在確認とListの初期化
      3. 出力の工夫
    2. まとめ：このステップで学ぶべきこと
    3. 🎯 実習で理解を深めよう

MapUtil.java

import java.util.*;

public class MapUtil {
    public static void printCategoryMap() {
        // Mapを作成。キーがカテゴリ（String）、値が商品名リスト（List<String>）
        Map<String, List<String>> categoryMap = new HashMap<>();

        // 商品を追加するユーティリティ処理
        // カテゴリがMapに存在しなければ新しくListを作る
        // すでに存在すれば、そのListに追加する

        addProduct(categoryMap, "Food", "Apple");
        addProduct(categoryMap, "Food", "Banana");
        addProduct(categoryMap, "Clothing", "T-shirt");
        addProduct(categoryMap, "Clothing", "Jeans");
        addProduct(categoryMap, "Food", "Orange");  // 既存のFoodカテゴリに追加

        // 出力：カテゴリごとに商品一覧を表示
        for (String category : categoryMap.keySet()) {
            System.out.println(category + ":");
            for (String product : categoryMap.get(category)) {
                System.out.println("  - " + product);
            }
        }
    }

    // 商品をカテゴリに追加するメソッド（Mapの値がListなので工夫が必要）
    private static void addProduct(Map<String, List<String>> map, String category, String product) {
        // すでにそのカテゴリがあるかチェック
        if (!map.containsKey(category)) {
            // なければ新しいリストを作成し、Mapにputする
            map.put(category, new ArrayList<>());
        }
        // カテゴリに対応するリストに商品を追加
        map.get(category).add(product);
    }
}

解説：Mapに複数の値を格納したいときは List を使え

なぜ Map<String, List<String>> が必要なのか？

JavaのMapは「1つのキーに1つの値」が原則です。
しかし「カテゴリ → 複数の商品」のように、1対多の関係を扱いたい場面では、
値としてListやSetなどのコレクションを使うのが一般的です。

実装のポイント：キーの存在確認とListの初期化

新しい商品を追加するたびに、以下の手順が必要になります：

  1. そのカテゴリ（キー）がMapに存在するか確認
  2. 存在しなければ、new ArrayList<>(); で初期化して put()
  3. そのリストに .add() で商品を追加
if (!map.containsKey(category)) {
    map.put(category, new ArrayList<>());
}
map.get(category).add(product);

この処理はよくあるため、ユーティリティメソッドにまとめて再利用するのがベストです。

出力の工夫

カテゴリ → 商品リストを表示するには、次のような二重ループになります：

for (String category : map.keySet()) {
    System.out.println(category + ":");
    for (String product : map.get(category)) {
        System.out.println("  - " + product);
    }
}

実行結果の例（順不同）：

Food:
  - Apple
  - Banana
  - Orange
Clothing:
  - T-shirt
  - Jeans

まとめ：このステップで学ぶべきこと

  • Map<String, List<String>> という構造
  • 1つのキーに複数の値を関連付ける設計方法
  • containsKey() での存在チェックと初期化
  • 二重ループによる出力処理

このステップを乗り越えれば、Mapを使った柔軟なデータ構造の基礎が身につきます。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Just Keep Typing, Baby!
Map修羅道：Step03「1つのキーに複数の値を格納するには？」
https://justkeeptyping.baby/archives/241

🎯 実習で理解を深めよう

この内容についてJavaDrillで実際に手を動かして学習できます

]]> https://minner.asia/archives/4951/feed 0 102 「Map修羅道」 Step02　解答例 https://minner.asia/archives/4940 https://minner.asia/archives/4940#respond Sun, 18 May 2025 23:44:30 +0000 http://localhost/?p=4940
  1. MapUtil.java
    1. 解説：Mapをループで出力する2つの方法
      1. 方法①：keySet() を使う
      2. 方法②：entrySet() を使う
    2. 実行結果の例（順不同）：
    3. まとめ：このステップで学ぶべきこと

MapUtil.java

import java.util.HashMap;
import java.util.Map;

public class MapUtil {
    public static void printDepartments() {
        // 社員番号と部署名を記録するMapを作成
        Map<Integer, String> departmentMap = new HashMap<>();

        // データを登録
        departmentMap.put(2001, "Sales");
        departmentMap.put(2002, "HR");
        departmentMap.put(2003, "Engineering");

        // ---- keySet() を使ったループ ----
        System.out.println("=== keySet() を使った出力 ===");
        for (Integer empId : departmentMap.keySet()) {
            // key（社員番号）から value（部署名）を取得する
            String department = departmentMap.get(empId);
            System.out.println(empId + " → " + department);
        }

        // ---- entrySet() を使ったループ ----
        System.out.println("=== entrySet() を使った出力 ===");
        for (Map.Entry<Integer, String> entry : departmentMap.entrySet()) {
            // entry から key と value を同時に取り出す
            Integer empId = entry.getKey();
            String department = entry.getValue();
            System.out.println(empId + " → " + department);
        }
    }
}

解説：Mapをループで出力する2つの方法

JavaのMapをループで出力するには、主に以下の2通りの方法があります。

方法①：keySet() を使う

for (Integer key : map.keySet()) {
    String value = map.get(key);
    System.out.println(key + " → " + value);
}
  • keySet() はすべてのキーを取得できる
  • キーから値を取得するために map.get(key) を毎回呼び出す必要がある
  • 単純だが、Mapが大きくなるとパフォーマンス面でやや不利

方法②：entrySet() を使う

for (Map.Entry<Integer, String> entry : map.entrySet()) {
    Integer key = entry.getKey();
    String value = entry.getValue();
    System.out.println(key + " → " + value);
}
  • entrySet() はキーと値のペア（Entry）を一括で扱える
  • getKey() と getValue() を使ってそれぞれ取得
  • Mapの中身をすべて処理する場面では推奨される方法

実行結果の例（順不同）：

=== keySet() を使った出力 ===
2001 → Sales
2002 → HR
2003 → Engineering

=== entrySet() を使った出力 ===
2001 → Sales
2002 → HR
2003 → Engineering

※ HashMap は順序を保証しないため、出力順は実行環境により異なる可能性があります。

まとめ：このステップで学ぶべきこと

  • Mapをループ処理する際の2通りの方法を体得する
  • keySet()は構造がシンプル、entrySet()は効率的
  • 実用上は entrySet() が推奨されるシーンが多い

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Map修羅道：Step02　Mapをループで出力するには？ - Just Keep Typing, Baby!
→ javadrill.tech で出題された問題を見る（Step02）
justkeeptyping.baby

// tesh:
// まだ納得してないやろ？ なら、こっち来い。
]]> https://minner.asia/archives/4940/feed 0 102 「Map修羅道」 Step01　解答例 https://minner.asia/archives/4932 https://minner.asia/archives/4932#respond Sun, 18 May 2025 23:27:57 +0000 http://localhost/?p=4932
  1. MapUtil.java
    1. 解説：Mapにおけるキーの重複
      1. 上書きの仕組み
      2. Mapの出力方法
      3. 順序についての注意
    2. まとめ：このステップで学ぶべきこと

MapUtil.java

import java.util.HashMap;
import java.util.Map;

public class MapUtil {
    public static void printMemberMap() {
        // Mapを作成。キーがInteger（会員番号）、値がString（名前）
        Map<Integer, String> memberMap = new HashMap<>();

        // 参加者を登録。最初に101番Yamadaを登録
        memberMap.put(101, "Yamada");

        // 102番Tanakaを登録
        memberMap.put(102, "Tanaka");

        // 101番Suzukiを登録 → すでに101番があるため、"Yamada" が "Suzuki" に上書きされる
        memberMap.put(101, "Suzuki");

        // Mapの内容を1件ずつ出力する（keyとvalueを取得）
        for (Map.Entry<Integer, String> entry : memberMap.entrySet()) {
            Integer key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + " → " + value);
        }
    }
}

解説：Mapにおけるキーの重複

この問題では、Mapに同じキー（ここでは101）を複数回 put() した場合に何が起こるかを体感することが目的です。

上書きの仕組み

JavaのMapでは、キーが重複している場合、新しい値で上書きされます。
例：

map.put(101, "Yamada");
map.put(101, "Suzuki");

この場合、Mapの中では 101 → "Suzuki" のみが保持されます。"Yamada" は消えます。

Mapの出力方法

Mapの出力には以下の方法があります：

  • for (Map.Entry<K, V> entry : map.entrySet())
    • キーと値を同時に扱う場合に便利
  • for (K key : map.keySet())
    • キーしか扱わないとき用（値は map.get(key) で取得）

この問題では、明示的にループして出力することが要件です。
したがって System.out.println(map) のような一発表示は禁止です。

順序についての注意

HashMap は キーの順序を保証しません。
たとえば、登録順に 101 → 102 → 101 と入れたとしても、出力順がそれと一致する保証はありません。

順序が重要な場面では LinkedHashMap や TreeMap を使う必要があります（後のステップで扱います）。

まとめ：このステップで学ぶべきこと

  • Mapに同じキーで put() すると値が上書きされる
  • Map.entrySet() を使ったループの書き方
  • HashMap は出力順序を保証しない

Mapの基本操作は、この「上書きされる」という挙動を理解することから始まります。

102 ステップアップ問題　「Map修羅道」

Just Keep Typing, Baby!では、この「Map修羅道」でつまづいた人向けの解説をしています。こちらもぜひ！

Map修羅道：Step01　重複したキーをどう扱う？ - Just Keep Typing, Baby!
→ javadrill.tech で出題された問題を見る（Step01）
justkeeptyping.baby

// tesh:
// 読み飛ばすと、あとで必ず後悔する系。読んどけ。
]]> https://minner.asia/archives/4932/feed 0