S-JIS[2014-07-06/2023-09-24] 変更履歴

java.util.Map

Javaのコレクションのひとつであるマップについて。

概要

マップは、キーとなるオブジェクト（よく使われるのは文字列や列挙型）に対し、それに該当する値を保持するコレクション。
→他言語のマップ（ディクショナリー・連想配列）

マップは、java.util.Mapインターフェースで表される。

Mapは（ListやSetとは異なり）CollectionやIterableインターフェースを継承していない。
したがって、全要素に対して順次処理を行いたい場合は、キーや値の一覧を取得し、それに対して処理する。
→順次アクセス処理

MapのサブインターフェースとしてSortedMap（キーの並び順が保持されるMap）があり、さらにその下にNavigableMapがある。
SortedMap（NavigableMap）の代表例はTreeMap。
他にConcurrentMapというインターフェースもあって、代表例はConcurrentHashMap。
さらにそのサブインターフェースにConcurrentNavigableMapがあり（これはNavigableMapも継承している）、代表例はConcurrentSkipListMap。

マップの具象クラス

Mapの主な具象クラス。

マップの初期化

配列だと初期値を列挙する初期化構文がある（ScalaのMapにも初期値を指定する方法がある）が、JavaのMapでは構文としては用意されていない。

マップのメソッド

Map関連の主なメソッド。

クラスやメソッドによっては、java.lang.UnsupportedOperationExceptionを返す実装もある。
例えばUnmodifiableMapは不変マップなので、値を変更するputやremoveメソッドを呼び出すとUnsupportedOperationExceptionが発生する。

ランダムアクセス操作

Mapは、キーを指定して値を取得する操作が効率的に行えるようになっている。

Map<String, String> map = new LinkedHashMap<>();
map.put("a", "foo");
map.put("b", "bar");
map.put("c", "zzz");

String value = map.get("b");

String getValue(Map<String, String> map, String key) {
  String value;
  if (map.containsKey(key)) {
    value = map.get(key);
  } else {
    value = "defaultValue";
  }
  return value;
}

String getValue(Map<String, String> map, String key) {
  String value = map.get(key);
  if (value == null && !map.containsKey(key)) {
    value = "defaultValue";
  }
  return value;
}

String getValue(Map<String, String> map, String key) {
  String value = map.get(key);
  if (value == null) {
    value = "defaultValue";
  }
  return value;
}

String getValue(Map<String, String> map, String key) {
  String value = map.getOrDefault(key, "defaultValue");
  return value;
}

void add(Map<String, List<String>> map, String key, String value) {
  List<String> list = map.get(key);
  if (list == null) {
    list = new ArrayList<>();
    map.put(key, list);
  }
  list.add(value);
}

void add(Map<String, List<String>> map, String key, String value) {
  List<String> list = map.computeIfAbsent(key, k -> new ArrayList<>());
  list.add(value);
}

void add(Map<String, List<String>> map, String key, String value) {
  List<String> list = new ArrayList<>();
  list.add(value);
  map.merge(key, list, (oldList, newList) -> {
    oldList.addAll(newList);
    return oldList;
  });
}

順次アクセス操作

Mapでは、保持している値（要素）を直接順次処理していくことが出来ない。（JDK1.8では出来るようになった→forEachの利用）
キーのSetや値のCollectionを取得し、それに対して処理を行う。

基本的には、処理される順序に保証は無い。
ただし、一部のクラス（LinkedHashMapやTreeMap・EnumMap等）では並び順が保証される。

keySet

Map#keySet()を使うと、キーの一覧を取得することが出来る。[2007-03-26]
キーが取れるのでMap#get()で値を取得することも出来るが、値だけが必要ならvalues()、キーと値の両方を使うならenrtySet()を使う方が良い。
（get()を呼び出すと、そこで値の探索処理が動いてしまうから）

for (Iterator i = map.keySet().iterator(); i.hasNext();) {
	キー型 キー = (キー型) i.next();
	値の型 変数 = (値の型) map.get(キー);
〜
}

for (Iterator<キー型> i = map.keySet().iterator(); i.hasNext();) {
	キー型 キー = i.next();
	値の型 変数 = map.get(キー);
〜
}

for (キー型 キー : map.keySet()) {
	値の型 変数 = map.get(キー);
〜
}

values

Map#values()を使うと、値の一覧を取得することが出来る。[2007-03-26]

for (Iterator i = map.values().iterator(); i.hasNext();) {
	値の型 変数 = (値の型) i.next();
〜
}

for (Iterator<値の型> i = map.values().iterator(); i.hasNext();) {
	値の型 変数 = i.next();
〜
}

for (値の型 変数 : map.values()) {
〜
}

→値の型を変換する例

entrySet

Map#entrySet()を使うと、キーと値の一覧を取得することが出来る。[2010-02-13]

import java.util.Map.Entry;

for (Iterator i = map.entrySet().iterator(); i.hasNext();) {
	Entry entry = (Entry) i.next();
	キー型 キー = (キー型) entry.getKey();
	値の型 変数 = (値の型) entry.getValue();
〜
}

for (Iterator<Entry<キー型, 値の型>> i = map.entrySet().iterator(); i.hasNext();) {
	Entry<キー型, 値の型> entry = i.next();
	キー型 キー = entry.getKey();
	値の型 変数 = entry.getValue();
〜
}

for (Entry<キー型, 値の型> entry : map.entrySet()) {
	キー型 キー = entry.getKey();
	値の型 変数 = entry.getValue();
〜
}

map.forEach((キー, 変数) -> {
〜
});

値の型を変換する例。[2018-02-04]

valuesメソッドは値一覧を取得できるだけで変換は出来ない。
entrySetメソッドでキーと値の両方を取得し、値だけを変換する。

Map<K, V1> map = 〜;
Map<K, V2> toMap = new HashMap<K, V2>(map.size());
for (Entry<K, V1> entry : map.entrySet()) {
	V2 value = convert(entry.getValue());
	toMap.put(entry.getKey(), value);
}

import java.util.AbstractMap.SimpleImmutableEntry;

Map<K, V2> toMap = map.entrySet().stream()
	.map(entry -> new SimpleImmutableEntry<>(entry.getKey(), convert(entry.getValue())))
	.collect(Collectors.toMap(Entry::getKey, Entry::getValue));

import static jp.t2v.lab.syntax.MapStreamSyntax.*;

Map<K, V2> toMap = map.entrySet().stream()
	.map(values(MapExample::convert))
	.collect(entryToMap());

Listへの変換

MapのキーをListに変換する方法。[2017-01-19]

	List<String> keyList = new ArrayList<>(map.keySet());

Mapの値をListに変換する方法。

	List<String> valueList = new ArrayList<>(map.values());

Streamとの変換

Mapから直接Streamを生成することは出来ない。

（ScalaのMapだと、「Mapは“キーと値のペア”の一覧（Seq）」という位置づけでもある為、直接Stream（キーと値の一覧）に変換することが出来る。
 しかしJavaのMapはそういう考え方ではない）

entrySet()やkeySet()・values()で他のコレクションに変換し、そこからStreamを生成する。

StreamからMapを生成するにはCollectors.toMapを使用する。

	Stream<String> stream = Stream.of("a:foo", "b:bar", "c:zzz");

	Map<String, String> map = stream.collect(Collectors.toMap(s -> s.split(":")[0], s -> s.split(":")[1]));

toMapの引数には、「Streamの要素を元にしてキーを生成する関数」と「Streamの要素を元にして値を生成する関数」を渡す。

java.util.HashMap

HashMapは、キーの検索にハッシュコードを利用して効率を良くしたマップ。[2007-12-22]
→HashMap内でのハッシュコードの使われ方

キーにはequals()とhashCode()が定義されていれば どんなオブジェクト（クラス）でも使えるが、不変であることが望ましい（というか、不変でないとまずそう）。
（StringやInteger・Longといったラッパークラスは不変なので キーとして使うのに何ら問題ない）

キーが可変（マップに入れた後で値を変更することによって equals()やhashCode()の結果が変わる）だと、以下のような問題が起きる可能性がある。

//可変なキーとするクラス
class Key {
	private String key;

	public Key(String k) {
		this.key = k;
	}

	public void setKey(String k) {
		this.key = k;
	}

	@Override
	public boolean equals(Object obj) {	//等しいかどうかは、保持している文字列で比較する
		if (obj instanceof Key) {
			Key k = (Key) obj;
			return key.equals(k.key);
		}
		return super.equals(obj);
	}

	@Override
	public int hashCode() {		//ハッシュ値は、保持している文字列のものを使用する
		return key.hashCode();
	}
}

	Key k1 = new Key("abc");
	Key k2 = new Key("abc");

	HashMap<Key, String> map = new HashMap<>();
	map.put(k1, "data");

	System.out.println("変更前：" + k1.equals(k2) + "/" + (k1.hashCode() == k2.hashCode()));
	System.out.println("k1:" + map.get(k1));
	System.out.println("k2:" + map.get(k2));

	k1.setKey("def"); //キーの中身を変更

	System.out.println("変更後：" + k1.equals(k2) + "/" + (k1.hashCode() == k2.hashCode()));
	System.out.println("k1:" + map.get(k1));
	System.out.println("k2:" + map.get(k2));

実行結果：

変更前：true/true
k1:data
k2:data
変更後：false/false
k1:null
k2:null

k1とk2は別インスタンスだが中身は同じなので、変更前はイコール（equals()がtrue）だし、ハッシュコードも等しい。
したがって、ハッシュマップからはk1でもk2でも値を取得することが出来る。

一方、マップに保持しているキーであるk1の内容を変えると、マップ内にk1のデータが残っているにも関わらず、k1で取得できない。
また、k2でも取得できない。
k2はk1と不一致（equals()がfalse）になったので取れなくなっても仕方ない。

k1でも取れなくなったのは、ハッシュ値が変わった為。（ハッシュ値の算出には保持している文字列を使っていたから）
ハッシュマップではキーのハッシュ値を元にハッシュマップ内のテーブル位置を決定する為、ハッシュ値が変わるとテーブル位置の算出結果が元のテーブル位置と異なってしまう（可能性がある）ので、見つけられなくなってしまう。
また、そこが偶然一致したとしても、テーブル位置内にある候補と比較する際にもハッシュ値そのものが使われているので、不一致になる可能性は高い。

試しにハッシュコードのメソッドを以下のように変えてやると、変更後もハッシュ値が変わらなくなるので取得できるようになる。

	public int hashCode() {		//デフォルトのハッシュ値を返す
		return super.hashCode();
	}

変更前：true/false
k1:data
k2:null
変更後：false/false
k1:data
k2:null

しかし見ての通り、キー値の変更前でもk2でデータを取得できなくなってしまった。ハッシュ値が一致しないのだから不思議ではない（運が良ければハッシュ値が一致して取得できただろうが、プログラムが運に頼ってどーする！むしろデバッグ（バグの再現性）の観点からは、一致したら超アンラッキー）。
そして『equals()がtrueの時は同一のハッシュコードを返さなければならない』のがhashCode()の決まりなので、そうでないのは仕様違反！
equals()もデフォルトのもの（インスタンスが等しければtrue）にすれば仕様は満たせるが、他インスタンスは必ず不一致になってしまい、ハッシュマップからは絶対に値が取れなくなる。

結局、マップのキーには不変の値を使った方が安全・安心ということ。

Java8では、HashMapのキーに使うクラスはComparableを実装しておく方が良いらしい。[2015-06-20]

• インタープリズムさんのJava8からはHashMapの性能のためにComparableを実装しておいた方がいい

java.util.LinkedHashMap

LinkedHashMapは、並び順が保証されているMap。

デフォルトではキーを追加した順番になるが、アクセス順にすることも出来る。

Map<String, String> map = new LinkedHashMap<>(4);
map.put("z", "1");
map.put("a", "9");
map.put("b", "2");
map.put("a", "8");
System.out.println(map);

Map<String, String> map = new LinkedHashMap<>(4, 0.75f, true);
map.put("z", "1");
map.put("a", "9");
map.put("b", "2");
map.put("a", "8");
System.out.println(map);

@SuppressWarnings("serial")
Map<String, Integer> map = new LinkedHashMap<String, Integer>() {
  private static final int MAX_ENTRIES = 4;

  @Override
  protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
    return size() > MAX_ENTRIES;
  }
};

for (int i = 0; i < 10; i++) {
  String key = String.format("%c", 'a' + i);
  int value = i + 1;
  map.put(key, value);
}
System.out.println(map);

@SuppressWarnings("serial")
Map<String, Integer> map = new LinkedHashMap<String, Integer>(4, 0.75f. true) {
  private static final int MAX_ENTRIES = 4;

  @Override
  protected boolean removeEldestEntry(Map.Entry<String, Integer> eldest) {
    return size() > MAX_ENTRIES;
  }
};

for (int i = 0; i < 10; i++) {
  String key = String.format("%c", 'a' + i);
  int value = i + 1;
  map.put(key, value);

  map.get("a"); // 常にaが最新アクセス
}
System.out.println(map);

java.util.TreeMap

TreeMapは、キーの順序で並ぶMap。

Map<String, String> map = new TreeMap<>();
map.put("z", "1");
map.put("a", "9");
map.put("b", "2");
map.put("a", "8");
System.out.println(map);

Map<String, String> map = new TreeMap<>(Comparator.reverseOrder());
map.put("z", "1");
map.put("a", "9");
map.put("b", "2");
System.out.println(map);

TreeMapのキーのnull

普通、Mapのキーにはnullを使うことが出来るのだが、TreeMapの場合はnullが許される場合と許されない場合がある。[2016-12-29]

デフォルトの場合（TreeMapのコンストラクターでComparatorを指定していない場合）は、key1.compareTo(key2)という比較を行うので、キーがnullだったらNullPointerExceptionが発生する。
TreeMapのコンストラクターでComparatorが指定されている場合は、そのComparatorでcompare(key1, key2)という呼び出しが行われる。したがって、そのcompareメソッドがnullを許容する作りになっていれば、TreeMap自体もnullキーを許容することになる。

Map.ofの不変マップ

Map.ofメソッド（Map.ofEntriesメソッド）で作られるマップは不変マップである。[2017-09-24]
キーや値にnullを入れる事は出来ない。
不変マップなので、putやremove等の操作を行おうとするとUnsupportedOperationExceptionが発生する。
keySetやvaluesの並び順は不定。

Java9では、実体のクラスはImmutableCollectionsの内部クラスとして定義されている。
キー数が0個のときはMap0、1個のときはMap1、それ以外はMapNというクラスである。

MapNは、キーと値を保持するのに（単純な）一次元配列だけを使用するので、メモリー使用効率はHashMapより良いと思われる。
キーの比較にはhashCodeやequalsを使っている。
putするときは、最初にhashCodeを元にインデックスを決め、配列のそのエントリーが空であればその位置を使う。空でなければ空の位置が見つかるまでインデックスをずらしていく。ハッシュテーブルの伝統的な実装方式のひとつである(笑)
getするときは、最初にhashCodeを元にインデックスを決め、配列のそのエントリーがequalsで一致すればその位置の値を返す。一致しない場合は、一致するか空になるまでインデックスをずらしていく。空の場合は一致するキーが無い。
（配列のエントリー数はキー数の2倍なので、必ず空のエントリーがある）