HashMap.getのnullがキー未登録か登録済みnullかをcontainsKeyで見分ける記事のアイキャッチ。

実装・エラー解決

JavaのHashMapでgetがnullになる原因|未登録・null値・キー不一致を確認

この記事でわかること

HashMapのgetがnullを返すのは、キーが登録されていない場合と、キーに対してnull値が登録されている場合の2通りです。getだけでは区別できないため、区別が必要ならcontainsKeyを使います。getOrDefaultもnull値が登録されている場合はnullを返すため、常に既定値になるわけではありません。可能ならMapへnullを格納せず、未登録・取得失敗・値なしの意味を設計上分けます。

新人SE
新人SE
Map.getがnullでした。キーがなかったという意味で処理して大丈夫ですか?
ポンコツSE
ポンコツSE
HashMapでは、そのキーにnullが登録されている場合もgetはnullです。業務上区別が必要ならcontainsKeyも確認します。

Mapはマスタ値、表示名、集計結果、キャッシュなど幅広く使われます。get(key) == nullを「キーなし」と決めつけると、登録済みだが値未設定という状態を見落とします。

逆に、毎回containsKeyしてからgetする必要もありません。null値を格納しない設計なら、getのnullを未登録として扱えます。重要なのはそのMapでnullが何を意味するかを決めることです。

この記事のポイント

  • HashMap.getのnullには2つの意味がある
  • containsKeyでキーの登録有無を区別できる
  • getOrDefaultは登録済みnullを既定値へ置き換えない
  • computeIfAbsentはnullを「値なし」として扱う
  • 可能ならMapへnullを入れない設計にする

XのJavaクイズで2種類のnullを確認する

HashMapへAliceのキーとnull値を登録し、AliceとBobをgetした結果を問うJavaクイズ画像。
Aliceはnull値を登録済み、Bobはキー自体がありません。

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

    public static Map<String, Integer> scoreFixture() {
        Map<String, Integer> scores = new HashMap<>();
        scores.put("Alice", null);
        scores.put("Carol", 80);
        return scores;
    }

X画像はAliceのnull登録とBobの未登録を比べた元の断片です。実行版はこの2人に、点数80のCarolを加えています。scoreFixture()が返す同じHashMapで3状態を比較します。Bobのキーはputしていません。

クリックで全文を開く:MapExamples.java:import・fixture・表示・キーの全例
package info.syachiku.hashmap;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

public final class MapExamples {
    private MapExamples() {
    }

    public static Map<String, Integer> scoreFixture() {
        Map<String, Integer> scores = new HashMap<>();
        scores.put("Alice", null);
        scores.put("Carol", 80);
        return scores;
    }

    public static String describeScore(Map<String, Integer> scores, String name) {
        Objects.requireNonNull(scores, "scores");
        Objects.requireNonNull(name, "name");
        Integer score = scores.get(name);
        if (score != null) {
            return "点数: " + score;
        }
        if (scores.containsKey(name)) {
            return "採点前";
        }
        return "受験者なし";
    }

    public static Map<String, String> labelFixture() {
        Map<String, String> labels = new HashMap<>();
        labels.put("A", null);
        labels.put("C", "登録値");
        return labels;
    }

    public static String defaultIfNull(Map<String, String> labels, String code) {
        String label = Objects.requireNonNull(labels, "labels")
                .get(Objects.requireNonNull(code, "code"));
        if (label == null) {
            label = "未設定";
        }
        return label;
    }

    public static Map<String, Integer> gradedOnly(String name, Integer score) {
        Objects.requireNonNull(name, "name");
        Map<String, Integer> scores = new HashMap<>();
        if (score != null) {
            scores.put(name, score);
        }
        return scores;
    }

    public static void putNullIntoConcurrentMap() {
        Map<String, String> map = new ConcurrentHashMap<>();
        map.put("A", null);
    }

    public static void putNullIntoMapOf() {
        Map.of("A", (String) null);
    }

    public static KeyObservation identityKeyObservation() {
        Map<Keys.IdentityKey, String> users = new HashMap<>();
        Keys.IdentityKey inserted = new Keys.IdentityKey("E001");
        users.put(inserted, "Alice");
        Keys.IdentityKey sameValue = new Keys.IdentityKey("E001");
        return new KeyObservation(users.get(sameValue),
                users.containsKey(sameValue), users.size());
    }

    public static KeyObservation mutableKeyObservation() {
        Map<Keys.MutableKey, String> users = new HashMap<>();
        Keys.MutableKey key = new Keys.MutableKey("E001");
        users.put(key, "Alice");
        key.setEmployeeNo("E002");
        return new KeyObservation(users.get(key), users.containsKey(key), users.size());
    }

    public static KeyObservation immutableKeyObservation() {
        Map<Keys.EmployeeKey, String> users = new HashMap<>();
        users.put(new Keys.EmployeeKey("E001"), "Alice");
        Keys.EmployeeKey sameValue = new Keys.EmployeeKey("E001");
        return new KeyObservation(users.get(sameValue),
                users.containsKey(sameValue), users.size());
    }

    public record KeyObservation(String value, boolean present, int size) {
    }
}
クリックで全文を開く:pom.xml:Java17/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>hashmap-null-1871</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>

クイズのAliceとBobはどちらもnullです。追加したCarolは80を返します。getの結果だけでは、AliceとBobの違いを判定できません。

HashMap.getはAliceもBobもnullだが、containsKeyではAliceがtrue、Bobがfalseになると説明する回答画像。
containsKeyなら、null値が登録済みかキー未登録かを区別できます。

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

containsKeyでキーの有無を判定する

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

        Map<String, Integer> scores = MapExamples.scoreFixture();
        for (String name : List.of("Carol", "Alice", "Bob")) {
            System.out.println(name + " get=" + scores.get(name)
                    + " containsKey=" + scores.containsKey(name)
                    + " getOrDefault=" + scores.getOrDefault(name, -1)
                    + " message=" + MapExamples.describeScore(scores, name));
        }

この例では登録済みの受験者全員をキーとして保持する名簿という契約です。だからAliceのnullは採点前、Bobのキーなしは受験者なしと表示できます。一部だけ読んだMapや未検索のキャッシュでは、キーなしを業務上の未登録と決めつけてはいけません。H10〜H12の表示期待値も、この名簿契約に対するものです。

検索キーgetcontainsKeygetOrDefault(-1)表示テスト
Carol80true80点数: 80H01/H04/H07/H10
Alicenulltruenull採点前H02/H05/H08/H11
Bobnullfalse-1受験者なしH03/H06/H09/H12

この例では、数値あり、キーありnull、キーなしに別の意味を持たせています。業務仕様で3状態が本当に必要な場合だけ、この区別を使います。

HashMapはキーと値の組を保持します。Aliceはキーが存在し、対応する値がnullです。Bobはキーが存在しません。containsKeyは値ではなくキーの登録有無を確認します。

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

    public static String describeScore(Map<String, Integer> scores, String name) {
        Objects.requireNonNull(scores, "scores");
        Objects.requireNonNull(name, "name");
        Integer score = scores.get(name);
        if (score != null) {
            return "点数: " + score;
        }
        if (scores.containsKey(name)) {
            return "採点前";
        }
        return "受験者なし";
    }

containsKey=falseだけで「登録処理を通っていない」とは断定できません。まず検索したキーの値・型がput時と同じかを確認し、独自の型ならequals/hashCode、put後にその判定へ使う値を変えていないかを調べます。次の3例では、size=1と検索結果を一緒に観測します。

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

    public static KeyObservation identityKeyObservation() {
        Map<Keys.IdentityKey, String> users = new HashMap<>();
        Keys.IdentityKey inserted = new Keys.IdentityKey("E001");
        users.put(inserted, "Alice");
        Keys.IdentityKey sameValue = new Keys.IdentityKey("E001");
        return new KeyObservation(users.get(sameValue),
                users.containsKey(sameValue), users.size());
    }

IdentityKeyは社員番号を持つだけで、Objectの参照同一性を使います。同じE001でも別インスタンスは一致しないため、get=null・containsKey=falseです。同じインスタンスなら検索できます(H26)。equals/hashCodeの規約を壊した例ではなく、業務で必要な「社員番号が同じなら同じキー」という等価性が未定義の例です。

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

    public static KeyObservation mutableKeyObservation() {
        Map<Keys.MutableKey, String> users = new HashMap<>();
        Keys.MutableKey key = new Keys.MutableKey("E001");
        users.put(key, "Alice");
        key.setEmployeeNo("E002");
        return new KeyObservation(users.get(key), users.containsKey(key), users.size());
    }

MutableKeyは社員番号をequals/hashCodeに使いますが、put後にE001からE002へ変更できます。JDK17.0.8のこの入力ではget=null・containsKey=false・size=1になりました(H28)。Map仕様は等価性へ影響するキー変更後の動作を規定していません。すべてのMapやJDKで必ずnullになるという保証ではなく、変更してはいけない値を変更できる設計の問題です。

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

    public static KeyObservation immutableKeyObservation() {
        Map<Keys.EmployeeKey, String> users = new HashMap<>();
        users.put(new Keys.EmployeeKey("E001"), "Alice");
        Keys.EmployeeKey sameValue = new Keys.EmployeeKey("E001");
        return new KeyObservation(users.get(sameValue),
                users.containsKey(sameValue), users.size());
    }

修正版はEmployeeKeyを不変recordにし、社員番号をput後に変更できなくします。同じE001の別インスタンスでequals=true・hashCode一致(H27)、get=Alice・containsKey=true(H29)を確認します。登録済みnullならcontainsKey=trueですが、falseは未登録とこれらのキー問題の両方で起きるため、結果だけで原因を決めないでください。

クリックで全文を開く:Keys.java:参照同一性・可変キーの不良例と不変キーの修正
package info.syachiku.hashmap;

import java.util.Objects;

public final class Keys {
    private Keys() {
    }

    // 意図的な不良例: equals/hashCodeを実装せず、インスタンス同一性で比較する。
    public static final class IdentityKey {
        private final String employeeNo;

        public IdentityKey(String employeeNo) {
            this.employeeNo = Objects.requireNonNull(employeeNo, "employeeNo");
        }
    }

    // 意図的な不良例: equals/hashCodeに使う値をput後に変更できる。
    public static final class MutableKey {
        private String employeeNo;

        public MutableKey(String employeeNo) {
            setEmployeeNo(employeeNo);
        }

        public void setEmployeeNo(String employeeNo) {
            this.employeeNo = Objects.requireNonNull(employeeNo, "employeeNo");
        }

        @Override
        public boolean equals(Object other) {
            return other instanceof MutableKey key
                    && employeeNo.equals(key.employeeNo);
        }

        @Override
        public int hashCode() {
            return employeeNo.hashCode();
        }
    }

    // 修正版: 等価性に使う社員番号を変更できない。
    public record EmployeeKey(String employeeNo) {
        public EmployeeKey {
            Objects.requireNonNull(employeeNo, "employeeNo");
        }
    }
}
関連記事HashMapで値が取れない原因はequalsかも 同じ値の別オブジェクトをキーにしたときのequals・hashCodeを詳しく確認できます。 記事を読む

getOrDefaultも登録済みnullには効かない

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

    public static Map<String, String> labelFixture() {
        Map<String, String> labels = new HashMap<>();
        labels.put("A", null);
        labels.put("C", "登録値");
        return labels;
    }

src/test/java/info/syachiku/hashmap/MapExamplesTest.javaからの抜粋です。

    @Test
    void H13_defaultIfNull_intentionallyCombinesNullAndMissing() {
        Map<String, String> labels = MapExamples.labelFixture();
        assertNull(labels.getOrDefault("A", "未設定"));
        assertEquals("未設定", labels.getOrDefault("B", "未設定"));
        assertEquals("未設定", MapExamples.defaultIfNull(labels, "A"));
        assertEquals("未設定", MapExamples.defaultIfNull(labels, "B"));
        assertEquals("登録値", MapExamples.defaultIfNull(labels, "C"));
    }

この節はラベル用のMapです。Aはnullを登録済み、Bは未登録、Cは文字列「登録値」を持ちます。直前の名簿と同じ3状態を、文字列の既定値「未設定」で比較します。次のH13はこのA/B/Cを使います。

getOrDefaultが既定値を返すのは、キーが存在しない場合です。キーAは存在するため、登録値nullがそのまま返ります。「nullなら常に既定値」というAPIではありません。

nullも既定値へ置き換えたいなら、要件を明示して処理します。

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

    public static String defaultIfNull(Map<String, String> labels, String code) {
        String label = Objects.requireNonNull(labels, "labels")
                .get(Objects.requireNonNull(code, "code"));
        if (label == null) {
            label = "未設定";
        }
        return label;
    }

ただし、この書き方ではキーなしと登録済みnullを同じ扱いにしています。それで正しいか確認します。

computeIfAbsentでキャッシュする時の注意

src/main/java/info/syachiku/hashmap/UserCaches.javaからの抜粋です。

    public static Optional<User> findWithNullableCache(
            Map<Long, User> cache, long userId, UserRepository repository) {
        Objects.requireNonNull(cache, "cache");
        Objects.requireNonNull(repository, "repository");
        User user = cache.computeIfAbsent(
                userId, id -> repository.findById(id).orElse(null));
        return Optional.ofNullable(user);
    }

computeIfAbsentはキーに値がない、または現在の値がnullの場合に計算処理を呼びます。ただし計算結果がnullなら、新しいキーとnull値の組は登録しません。次回もRepository検索が走ります。もともとそのキーにnullを登録していた場合は、nullの組が残ることと再検索することを分けて確認します。

「見つからなかったこと」もキャッシュしたいなら、Optionalや専用の結果型を値にする方法があります。

src/main/java/info/syachiku/hashmap/UserCaches.javaからの抜粋です。

    public static Optional<User> findWithOptionalCache(
            Map<Long, Optional<User>> cache, long userId, UserRepository repository) {
        Objects.requireNonNull(cache, "cache");
        Objects.requireNonNull(repository, "repository");
        return cache.computeIfAbsent(userId, repository::findById);
    }

キャッシュ側の状態は、entryなしが未検索、Optional.emptyを保持していれば検索済みだが未検出、Optional.ofを保持していれば見つかったです。名簿の「受験者なし」という表示とは意味が違います。H15/H16は同じ未検出結果でも、Mapがその結果を保持できたかと検索回数を分けて検査します。

両メソッドは、呼び出し側へ同じOptional<User>を返します。UserRepositoryの契約は「未検出ならOptional.empty、戻り値自体はnullにしない」です。CountingUserRepositoryはIDごとの検索回数を数えます。空のRepositoryへ同じID2を3回問い合わせると、戻り値は両方とも3回ともemptyですが、検索回数が変わります。

入力と方式Repository回数/戻り値最後のMap状態テスト
未検出ID2を3回、空のキャッシュ3回/emptyID2は未登録H15
未検出ID2を3回、Optional版1回/emptyID2→Optional.emptyありH16
存在するID1を3回、両方式各1回/同じUsernullableはUser、Optional版はOptional.of(User)H17
ID2→nullが元からあるnullable版3回/emptyID2→nullが残るH18

この比較は1スレッドで短い間に3回呼ぶ教材です。キャッシュの失効・TTL・更新伝播・上限・同時実行は実装も検証もしていません。Optional.emptyは検索済み0件を表し、接続失敗を握りつぶす値ではありません。

クリックで全文を開く:UserCaches.java:同じOptional戻り値で2方式を比較
package info.syachiku.hashmap;

import java.util.Map;
import java.util.Objects;
import java.util.Optional;

public final class UserCaches {
    private UserCaches() {
    }

    public static Optional<User> findWithNullableCache(
            Map<Long, User> cache, long userId, UserRepository repository) {
        Objects.requireNonNull(cache, "cache");
        Objects.requireNonNull(repository, "repository");
        User user = cache.computeIfAbsent(
                userId, id -> repository.findById(id).orElse(null));
        return Optional.ofNullable(user);
    }

    public static Optional<User> findWithOptionalCache(
            Map<Long, Optional<User>> cache, long userId, UserRepository repository) {
        Objects.requireNonNull(cache, "cache");
        Objects.requireNonNull(repository, "repository");
        return cache.computeIfAbsent(userId, repository::findById);
    }
}
クリックで全文を開く:User.java:キャッシュするIDと名前
package info.syachiku.hashmap;

import java.util.Objects;

public record User(long id, String name) {
    public User {
        Objects.requireNonNull(name, "name");
    }
}
クリックで全文を開く:UserRepository.java:検索の型
package info.syachiku.hashmap;

import java.util.Optional;

public interface UserRepository {
    Optional<User> findById(long id);
}
クリックで全文を開く:CountingUserRepository.java:固定データとID別検索回数
package info.syachiku.hashmap;

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

public final class CountingUserRepository implements UserRepository {
    private final Map<Long, User> users;
    private final Map<Long, Integer> calls = new HashMap<>();

    public CountingUserRepository(Map<Long, User> users) {
        this.users = Map.copyOf(users);
    }

    @Override
    public Optional<User> findById(long id) {
        calls.merge(id, 1, Integer::sum);
        return Optional.ofNullable(users.get(id));
    }

    public int callsFor(long id) {
        return calls.getOrDefault(id, 0);
    }
}

ただしキャッシュの有効期限、更新、メモリ上限、同時実行まで考える必要があります。本番用途ではCaffeineやSpring Cacheなど案件標準の仕組みを優先し、HashMapで独自キャッシュを作らない方が安全です。

Mapへnullを入れない設計を優先する

3状態が不要なら、nullを格納しない方が呼び出し側は単純になります。

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

    public static Map<String, Integer> gradedOnly(String name, Integer score) {
        Objects.requireNonNull(name, "name");
        Map<String, Integer> scores = new HashMap<>();
        if (score != null) {
            scores.put(name, score);
        }
        return scores;
    }

未採点を表したいなら、nullではなく状態を持つ型にできます。

package info.syachiku.hashmap;

import java.util.Objects;

public record ScoreResult(ScoreStatus status, Integer score) {
    public ScoreResult {
        Objects.requireNonNull(status, "status");
        if (status == ScoreStatus.GRADED && score == null) {
            throw new IllegalArgumentException("採点済みには点数が必要です");
        }
        if (status == ScoreStatus.NOT_GRADED && score != null) {
            throw new IllegalArgumentException("採点前には点数を持たせません");
        }
    }

    public static ScoreResult graded(int score) {
        return new ScoreResult(ScoreStatus.GRADED, score);
    }

    public static ScoreResult notGraded() {
        return new ScoreResult(ScoreStatus.NOT_GRADED, null);
    }
}
package info.syachiku.hashmap;

public enum ScoreStatus {
    NOT_GRADED,
    GRADED
}

GRADED+null、NOT_GRADED+数値はIllegalArgumentException、status=nullはNullPointerExceptionとして作成時に拒否します(H21〜H23)。0点は有効です(H19)。ここでは点数の上限・下限という別の業務ルールを追加せず、「採点状態と点数の有無が矛盾しない」契約に絞っています。

recordにしただけでは、Mapへnullをputすることまで防げません。次のScoreBoardは内部Mapを公開せず、registerでnameとScoreResult自体のnullを拒否します。NOT_GRADEDのscoreはnullでも、Map値であるScoreResultはnullにしません。H24はAlice/Carol/Bobの表示が元の3状態と同じであること、H25は登録境界のnull拒否を確認します。

package info.syachiku.hashmap;

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

public final class ScoreBoard {
    private final Map<String, ScoreResult> results = new HashMap<>();

    public void register(String name, ScoreResult result) {
        results.put(Objects.requireNonNull(name, "name"),
                Objects.requireNonNull(result, "result"));
    }

    public String describe(String name) {
        ScoreResult result = results.get(Objects.requireNonNull(name, "name"));
        if (result == null) {
            return "受験者なし";
        }
        if (result.status() == ScoreStatus.NOT_GRADED) {
            return "採点前";
        }
        return "点数: " + result.score();
    }
}

少しコードは増えますが、nullの意味をコメントで補わず型で表せます。業務上重要な状態ほど、nullへ複数の意味を詰め込まないようにします。

HashMap以外ではnullの仕様が違う

Mapインターフェースを実装するすべてのクラスがnullを許すわけではありません。たとえばConcurrentHashMapはnullキーとnull値を許可しません。Map.ofもnullを許可しません。

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

    public static void putNullIntoConcurrentMap() {
        Map<String, String> map = new ConcurrentHashMap<>();
        map.put("A", null);
    }

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

    public static void putNullIntoMapOf() {
        Map.of("A", (String) null);
    }

2つのメソッドは、それぞれのnull拒否を試す意図的な例外例です。H30では別々のassertThrowsで呼びます。ひとつのmainへ続けて書いて最初の例外で止め、Map.ofを実行したつもりになる構成ではありません。

変数型がMapでも、具体的な生成方法で挙動が変わります。後からHashMapをConcurrentHashMapへ変更する予定があるなら、最初からnullを入れない契約にしておくと移行しやすくなります。

テストで3状態を固定する

クリックで全文を開く:MapExamplesTest.java:3状態・検索回数・型契約・キーを検査する30件
package info.syachiku.hashmap;

import org.junit.jupiter.api.Test;

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

import static org.junit.jupiter.api.Assertions.*;

class MapExamplesTest {
    @Test
    void H01_get_returnsRegisteredValue() {
        assertEquals(80, MapExamples.scoreFixture().get("Carol"));
    }

    @Test
    void H02_get_returnsRegisteredNull() {
        assertNull(MapExamples.scoreFixture().get("Alice"));
    }

    @Test
    void H03_get_returnsNullForMissingKey() {
        assertNull(MapExamples.scoreFixture().get("Bob"));
    }

    @Test
    void H04_containsKey_isTrueForValue() {
        assertTrue(MapExamples.scoreFixture().containsKey("Carol"));
    }

    @Test
    void H05_containsKey_isTrueForRegisteredNull() {
        assertTrue(MapExamples.scoreFixture().containsKey("Alice"));
    }

    @Test
    void H06_containsKey_isFalseForMissingKey() {
        assertFalse(MapExamples.scoreFixture().containsKey("Bob"));
    }

    @Test
    void H07_getOrDefault_preservesValue() {
        assertEquals(80, MapExamples.scoreFixture().getOrDefault("Carol", -1));
    }

    @Test
    void H08_getOrDefault_preservesRegisteredNull() {
        assertNull(MapExamples.scoreFixture().getOrDefault("Alice", -1));
    }

    @Test
    void H09_getOrDefault_returnsDefaultOnlyWhenMissing() {
        assertEquals(-1, MapExamples.scoreFixture().getOrDefault("Bob", -1));
    }

    @Test
    void H10_describeScore_hasGradedMessage() {
        assertEquals("点数: 80", MapExamples.describeScore(MapExamples.scoreFixture(), "Carol"));
    }

    @Test
    void H11_describeScore_hasNotGradedMessage() {
        assertEquals("採点前", MapExamples.describeScore(MapExamples.scoreFixture(), "Alice"));
    }

    @Test
    void H12_describeScore_hasMissingMessage() {
        assertEquals("受験者なし", MapExamples.describeScore(MapExamples.scoreFixture(), "Bob"));
    }

    @Test
    void H13_defaultIfNull_intentionallyCombinesNullAndMissing() {
        Map<String, String> labels = MapExamples.labelFixture();
        assertNull(labels.getOrDefault("A", "未設定"));
        assertEquals("未設定", labels.getOrDefault("B", "未設定"));
        assertEquals("未設定", MapExamples.defaultIfNull(labels, "A"));
        assertEquals("未設定", MapExamples.defaultIfNull(labels, "B"));
        assertEquals("登録値", MapExamples.defaultIfNull(labels, "C"));
    }

    @Test
    void H14_gradedOnly_skipsNullButKeepsZero() {
        assertTrue(MapExamples.gradedOnly("Alice", null).isEmpty());
        assertEquals(Map.of("Alice", 0), MapExamples.gradedOnly("Alice", 0));
    }

    @Test
    void H15_nullableCache_repeatsThreeMissingQueries() {
        CountingUserRepository repository = new CountingUserRepository(Map.of());
        Map<Long, User> cache = new HashMap<>();
        for (int i = 0; i < 3; i++) {
            assertEquals(Optional.empty(), UserCaches.findWithNullableCache(cache, 2L, repository));
        }
        assertEquals(3, repository.callsFor(2L));
        assertFalse(cache.containsKey(2L));
    }

    @Test
    void H16_optionalCache_storesMissingAndQueriesOnce() {
        CountingUserRepository repository = new CountingUserRepository(Map.of());
        Map<Long, Optional<User>> cache = new HashMap<>();
        for (int i = 0; i < 3; i++) {
            assertEquals(Optional.empty(), UserCaches.findWithOptionalCache(cache, 2L, repository));
        }
        assertEquals(1, repository.callsFor(2L));
        assertTrue(cache.containsKey(2L));
        assertEquals(Optional.empty(), cache.get(2L));
    }

    @Test
    void H17_bothCaches_keepSameFoundUserAndQueryOnce() {
        User alice = new User(1L, "Alice");
        CountingUserRepository nullRepository = new CountingUserRepository(Map.of(1L, alice));
        CountingUserRepository optionalRepository = new CountingUserRepository(Map.of(1L, alice));
        Map<Long, User> nullableCache = new HashMap<>();
        Map<Long, Optional<User>> optionalCache = new HashMap<>();
        for (int i = 0; i < 3; i++) {
            Optional<User> actual = UserCaches.findWithNullableCache(nullableCache, 1L, nullRepository);
            assertEquals(Optional.of(alice), actual);
            assertEquals(actual, UserCaches.findWithOptionalCache(optionalCache, 1L, optionalRepository));
        }
        assertEquals(1, nullRepository.callsFor(1L));
        assertEquals(1, optionalRepository.callsFor(1L));
    }

    @Test
    void H18_existingNullAndNullCalculation_leaveEntryAndRepeatQuery() {
        CountingUserRepository repository = new CountingUserRepository(Map.of());
        Map<Long, User> cache = new HashMap<>();
        cache.put(2L, null);
        for (int i = 0; i < 3; i++) {
            assertEquals(Optional.empty(), UserCaches.findWithNullableCache(cache, 2L, repository));
        }
        assertEquals(3, repository.callsFor(2L));
        assertTrue(cache.containsKey(2L));
        assertNull(cache.get(2L));
    }

    @Test
    void H19_gradedResult_acceptsZero() {
        ScoreResult result = ScoreResult.graded(0);
        assertEquals(ScoreStatus.GRADED, result.status());
        assertEquals(0, result.score());
    }

    @Test
    void H20_notGradedResult_hasExplicitStatus() {
        ScoreResult result = ScoreResult.notGraded();
        assertEquals(ScoreStatus.NOT_GRADED, result.status());
        assertNull(result.score());
    }

    @Test
    void H21_gradedResult_rejectsNullScore() {
        assertThrows(IllegalArgumentException.class,
                () -> new ScoreResult(ScoreStatus.GRADED, null));
    }

    @Test
    void H22_notGradedResult_rejectsNumericScore() {
        assertThrows(IllegalArgumentException.class,
                () -> new ScoreResult(ScoreStatus.NOT_GRADED, 80));
    }

    @Test
    void H23_scoreResult_rejectsNullStatus() {
        assertThrows(NullPointerException.class, () -> new ScoreResult(null, null));
    }

    @Test
    void H24_scoreBoard_preservesThreeDisplayMessages() {
        ScoreBoard board = new ScoreBoard();
        board.register("Alice", ScoreResult.notGraded());
        board.register("Carol", ScoreResult.graded(80));
        for (String name : new String[]{"Alice", "Carol", "Bob"}) {
            assertEquals(MapExamples.describeScore(MapExamples.scoreFixture(), name), board.describe(name));
        }
    }

    @Test
    void H25_scoreBoard_rejectsNullAtRegistrationBoundary() {
        ScoreBoard board = new ScoreBoard();
        assertThrows(NullPointerException.class, () -> board.register("Alice", null));
        assertThrows(NullPointerException.class, () -> board.register(null, ScoreResult.notGraded()));
        assertThrows(NullPointerException.class, () -> board.describe(null));
    }

    @Test
    void H26_identityKey_differentInstanceDoesNotMatchSameEmployeeNo() {
        MapExamples.KeyObservation actual = MapExamples.identityKeyObservation();
        assertNull(actual.value());
        assertFalse(actual.present());
        assertEquals(1, actual.size());
        Map<Keys.IdentityKey, String> users = new HashMap<>();
        Keys.IdentityKey key = new Keys.IdentityKey("E001");
        users.put(key, "Alice");
        assertEquals("Alice", users.get(key));
    }

    @Test
    void H27_immutableKeys_haveMatchingEqualsAndHashCode() {
        Keys.EmployeeKey first = new Keys.EmployeeKey("E001");
        Keys.EmployeeKey second = new Keys.EmployeeKey("E001");
        assertNotSame(first, second);
        assertEquals(first, second);
        assertEquals(first.hashCode(), second.hashCode());
        assertNotEquals(first, new Keys.EmployeeKey("E002"));
    }

    @Test
    void H28_mutableKey_observationOnVerifiedJdk17() {
        // Map仕様は等価性に影響するキー変更後の動作を保証しない。
        // これは当サンプルを実行したJDK17の観測値を固定する検査。
        MapExamples.KeyObservation actual = MapExamples.mutableKeyObservation();
        assertNull(actual.value());
        assertFalse(actual.present());
        assertEquals(1, actual.size());
    }

    @Test
    void H29_immutableKey_findsDifferentInstance() {
        assertEquals(new MapExamples.KeyObservation("Alice", true, 1),
                MapExamples.immutableKeyObservation());
    }

    @Test
    void H30_nullRejection_isCheckedSeparatelyForEachImplementation() {
        assertThrows(NullPointerException.class, MapExamples::putNullIntoConcurrentMap);
        assertThrows(NullPointerException.class, MapExamples::putNullIntoMapOf);
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put(null, null);
        assertTrue(hashMap.containsKey(null));
    }
}

H01〜H12は最初の表の4列×3状態、H13〜H14は既定値と採点済みだけ保存する契約、H15〜H18は同じ結果と検索回数、H19〜H25は状態型と登録境界、H26〜H29はキー、H30は具体的Map実装のnull挙動を検査します。全文は上の「クリックで全文を開く」を押すと読めます。

クリックで全文を開く:Main.java:3状態と検索回数とキーの観測入口
package info.syachiku.hashmap;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

public final class Main {
    private Main() {
    }

    public static void main(String[] args) {
        Map<String, Integer> scores = MapExamples.scoreFixture();
        for (String name : List.of("Carol", "Alice", "Bob")) {
            System.out.println(name + " get=" + scores.get(name)
                    + " containsKey=" + scores.containsKey(name)
                    + " getOrDefault=" + scores.getOrDefault(name, -1)
                    + " message=" + MapExamples.describeScore(scores, name));
        }
        CountingUserRepository nullRepository = new CountingUserRepository(Map.of());
        CountingUserRepository optionalRepository = new CountingUserRepository(Map.of());
        Map<Long, User> nullableCache = new HashMap<>();
        Map<Long, Optional<User>> optionalCache = new HashMap<>();
        for (int i = 0; i < 3; i++) {
            UserCaches.findWithNullableCache(nullableCache, 2L, nullRepository);
            UserCaches.findWithOptionalCache(optionalCache, 2L, optionalRepository);
        }
        System.out.println("missing3 nullableCalls=" + nullRepository.callsFor(2L)
                + " optionalCalls=" + optionalRepository.callsFor(2L));
        System.out.println("identity=" + MapExamples.identityKeyObservation());
        System.out.println("mutable JDK17 observation=" + MapExamples.mutableKeyObservation());
        System.out.println("immutable=" + MapExamples.immutableKeyObservation());
    }
}
mvn clean test
java -cp target/classes info.syachiku.hashmap.Main
Carol get=80 containsKey=true getOrDefault=80 message=点数: 80
Alice get=null containsKey=true getOrDefault=null message=採点前
Bob get=null containsKey=false getOrDefault=-1 message=受験者なし
missing3 nullableCalls=3 optionalCalls=1
identity=KeyObservation[value=null, present=false, size=1]
mutable JDK17 observation=KeyObservation[value=null, present=false, size=1]
immutable=KeyObservation[value=Alice, present=true, size=1]

故障を見つける検査になっているかも確認しました。検証用コピーでfindWithOptionalCacheのreturnだけをreturn repository.findById(userId);へ変え、mvn test '-Dtest=MapExamplesTest#H16*'を実行すると、戻り値はemptyのままでも検索回数expected 1 / actual 3で失敗します。元のcomputeIfAbsentへ戻し全30件成功へ復元しました。原本/ZIP展開先でも全30件とMain出力の一致を確認しています。

キーありの値、キーありnull、キーなしを分けてテストします。nullを禁止する設計なら、putする境界でObjects.requireNonNullを使うテストも有効です。

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

// レビューコメント例
getがnullでも、キー未登録と登録済みnullの両方が考えられます。
このMapで必要な状態を確認し、必要ならcontainsKeyで分けてください。

// レビューコメント例
getOrDefaultはキーAにnullが登録されている場合、既定値を返しません。
nullも置換する要件なら明示的に処理してください。

// レビューコメント例
nullへ「未検索」と「検索済み0件」の2つの意味を持たせています。
結果型かOptionalで状態を分けたいです。

提出前のセルフチェック

  • Mapのnullが何を意味するか決めたか
  • キーなしと登録済みnullを区別する必要があるか
  • 必要ならcontainsKeyを使ったか
  • getOrDefaultの登録済みnull挙動を理解したか
  • computeIfAbsentの計算結果がnullにならないか
  • Mapへnullを入れない設計にできないか
  • 具体実装がnullを許可するか確認したか
  • 3状態をテストしたか

Mapとnullを基礎から整理する参考書

Mapの主要APIと実装クラスの違いを体系的に押さえると、null判定やキャッシュ処理の判断が安定します。

今回のif分岐やMap<String, Integer>の宣言、参照型とnullの関係がまだ読みづらい人は、『スッキリわかるJava入門 第5版』で変数・条件分岐・クラス・例外とコレクションの基礎を押さえてから、3状態の表へ戻ってみてください。APIの戻り値を読めることと、業務でどの状態を区別するか決めることを分けて進められます。

書籍「スッキリわかるJava入門 第5版」の表紙
商品画像:Amazon.co.jp
PR Java初学者向け

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

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

変数・条件分岐から、クラスの基本まで学ぶ一冊。

豊富な図とサンプルで、変数、条件分岐、クラス、例外処理まで順番に学べます。Javaの最初の教科書を探している人向けです。

  • Javaを基礎から体系的に学びたい
  • Java 25 LTS対応の入門書を選びたい

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

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

関連記事Javaのnullチェック入門 Objects.equalsや境界でのnull対策を基礎から整理します。 記事を読む 関連記事JavaのequalsとhashCode入門 HashMapがキーを見つける仕組みをオブジェクト比較から学べます。 記事を読む

まとめ

HashMap.getがnullを返すのは、キーが存在しない場合と、キーにnull値が登録されている場合の2通りです。区別が必要ならcontainsKeyを使います。

getOrDefaultやcomputeIfAbsentにもnull固有の挙動があります。可能ならMapへnullを格納せず、未登録・検索済み0件・値未設定を型や状態で分け、テストで契約を固定しましょう。

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