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


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を確認する

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の違いを判定できません。

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の表示期待値も、この名簿契約に対するものです。
| 検索キー | get | containsKey | getOrDefault(-1) | 表示 | テスト |
|---|---|---|---|---|---|
| Carol | 80 | true | 80 | 点数: 80 | H01/H04/H07/H10 |
| Alice | null | true | null | 採点前 | H02/H05/H08/H11 |
| Bob | null | false | -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");
}
}
}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回/empty | ID2は未登録 | H15 |
| 未検出ID2を3回、Optional版 | 1回/empty | ID2→Optional.emptyあり | H16 |
| 存在するID1を3回、両方式 | 各1回/同じUser | nullableはUser、Optional版はOptional.of(User) | H17 |
| ID2→nullが元からあるnullable版 | 3回/empty | ID2→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.MainCarol 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版
変数・条件分岐から、クラスの基本まで学ぶ一冊。
豊富な図とサンプルで、変数、条件分岐、クラス、例外処理まで順番に学べます。Javaの最初の教科書を探している人向けです。
- Javaを基礎から体系的に学びたい
- Java 25 LTS対応の入門書を選びたい
当サイトはAmazonアソシエイト・プログラムの参加者です。価格・在庫・配送条件はAmazonでご確認ください。
この記事とあわせて読みたい
まとめ
HashMap.getがnullを返すのは、キーが存在しない場合と、キーにnull値が登録されている場合の2通りです。区別が必要ならcontainsKeyを使います。
getOrDefaultやcomputeIfAbsentにもnull固有の挙動があります。可能ならMapへnullを格納せず、未登録・検索済み0件・値未設定を型や状態で分け、テストで契約を固定しましょう。



