JavaのNavigableMapの使い方について記載しています。
目次
NavigableMapの使い方
NavigableMap は、SortedMapインタフェースを継承しており、次の機能を使用することができます。
1. Mapの最初・最後の要素を取得
2. Mapの最初・最後の要素を取得と同時に削除
3. Mapから指定したキー値と同じ、もしくはもっとも近い要素を取得
4. Mapから指定した条件に該当する部分要素を取得
5. Mapに格納されている要素を逆順で取得
6. Mapに格納されている要素のkey一覧を取得
1. Mapの最初・最後の要素を取得
次のメソッドを使用します。
| メソッド | 戻り値 | 処理 |
|---|---|---|
| firstEntry() | Map.Entry<K,V> | Mapから最小のキーの、キーと値を取得します。 |
| lastEntry() | Map.Entry<K,V> | Mapから最大のキーの、キーと値を取得します。 |
実行例（ firstEntry() ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // 最小のキーのキーと値を取得 Map.Entry<Integer, String> rsltMap = map.firstEntry(); System.out.println(rsltMap); // 1=one // キーを取得 Integer key = rsltMap.getKey(); System.out.println(key); // 1 // 値を取得 String value = rsltMap.getValue(); System.out.println(value); // oneじ |
実行例（ lastEntry() ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // 最大のキーのキーと値を取得 Map.Entry<Integer, String> rsltMap = map.lastEntry(); System.out.println(rsltMap); // 3=three // キーを取得 Integer key = rsltMap.getKey(); System.out.println(key); // 3 // 値を取得 String value = rsltMap.getValue(); System.out.println(value); // three |
2. Mapの最初・最後の要素を取得と同時に削除
次のメソッドを使用します。
| メソッド | 戻り値 | 処理 |
|---|---|---|
| pollFirstEntry() | Map.Entry<K,V> | Mapから最小のキーの、キーと値を取得し、削除します。 Mapが空の場合は、nullを返します。 |
| pollLastEntry() | Map.Entry<K,V> | Mapから最大のキーの、キーと値を取得し、削除します。 Mapが空の場合は、nullを返します。 |
実行例（ pollFirstEntry() ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // 最小のキーのキーと値を取得 Map.Entry<Integer, String> rsltMap = map.pollFirstEntry(); System.out.println(rsltMap); // 1=one // キーを取得 Integer key = rsltMap.getKey(); System.out.println(key); // 1 // 値を取得 String value = rsltMap.getValue(); System.out.println(value); // one // 取得した要素は、取得元のMapから削除されます System.out.println(map); // {2=two, 3=three} // Mapが空の場合は、null を返します NavigableMap<Integer,String> map2 = new TreeMap<>(); Map.Entry<Integer, String> rsltMap2 = map2.pollFirstEntry(); System.out.println(rsltMap2); // null |
実行例（ pollLastEntry() ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // 最大のキーのキーと値を取得 Map.Entry<Integer, String> rsltMap = map.pollLastEntry(); System.out.println(rsltMap); // 3=three // キーを取得 Integer key = rsltMap.getKey(); System.out.println(key); // 3 // 値を取得 String value = rsltMap.getValue(); System.out.println(value); // three // 取得した要素は、取得元のMapから削除されます System.out.println(map); // {1=one, 2=two} // Mapが空の場合は、null を返します NavigableMap<Integer,String> map2 = new TreeMap<>(); Map.Entry<Integer, String> rsltMap2 = map2.pollLastEntry(); System.out.println(rsltMap2); // null |
3. Mapから指定したキー値と同じ、もしくはもっとも近い要素を取得
次のメソッドを使用します。
| メソッド | 戻り値 | 取得値（X） | 処理 |
|---|---|---|---|
| lowerEntry (K key) |
Map.Entry <K,V> |
key > X | 指定したキー未満で最大のキー値を持つ、キーと値のペアを返します。 該当するキーが存在しない場合は、nullを返します。 |
| lowerKey (K key) |
K | key > X | 指定したキー未満で最大のキー値を返します。 該当するキーが存在しない場合は、nullを返します。 |
| floorEntry (K key) |
Map.Entry <K,V> |
key >= X | 指定したキー以下で最大のキー値を持つ、キーと値のペアを返します。 該当するキーが存在しない場合は、nullを返します。 |
| floorKey (K key) |
K | key >= X | 指定したキー以下で最大のキー値を返します。 該当するキーが存在しない場合は、nullを返します。 |
| higherEntry (K key) |
Map.Entry <K,V> |
key < X | 指定したキーより大きく最小のキー値を持つ、キーと値のペアを返します。 該当するキーが存在しない場合は、nullを返します。 |
| higherKey (K key) |
K | key < X | 指定したキーより大きく最小のキー値を返します。 該当するキーが存在しない場合は、nullを返します。 |
| ceilingEntry (K key) |
Map.Entry <K,V> |
key <= X | 指定したキー以上で最小のキー値を持つ、キーと値のペアを返します。 該当するキーが存在しない場合は、nullを返します。 |
| ceilingKey (K key) |
K | key <= X | 指定したキー以上で最小のキー値を返します。 該当するキーが存在しない場合は、nullを返します。 |
3-1. lowerEntry・lowerKey
指定したキー未満で最大のキーを取得することができます。
実行例（ lowerEntry(K key) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // 3未満の最大値を取得 Map.Entry<Integer,String> rsltMap1 = map.lowerEntry(3); System.out.println(rsltMap1); // 2=two // 1未満の最大値を取得（該当するキーがないため、null が返ります） Map.Entry<Integer,String> rsltMap2 = map.lowerEntry(1); System.out.println(rsltMap2); // null |
実行例（ lowerKey(K key) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // 3未満の最大値を取得 Integer rsltKey1 = map.lowerKey(3); System.out.println(rsltKey1); // 2 // 1未満の最大値を取得（該当するキーがないため、null が返ります） Integer rsltKey2 = map.lowerKey(1); System.out.println(rsltKey2); // null |
3-2. floorEntry・floorKey
指定したキー以下で最大のキーを取得することができます。
実行例（ floorEntry(K key) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(4, "four"); map.put(5, "five"); // ------------------------------------------------- // 2以下の最大のキーの key・value を取得 // ------------------------------------------------- Map.Entry<Integer,String> rsltMap1 = map.floorEntry(2); System.out.println(rsltMap1); // 2=two // keyを取得 Integer key1 = rsltMap1.getKey(); System.out.println(key1); // 2 // valueを取得 String value1 = rsltMap1.getValue(); System.out.println(value1); // two // ------------------------------------------------- // 3以下の最大のキーの key・value を取得 // ------------------------------------------------- Map.Entry<Integer,String> rsltMap2 = map.floorEntry(3); System.out.println(rsltMap2); // 2=two // ------------------------------------------------- // 0以下の最大のキーの key・value を取得（該当するキーがないため、null が返ります） // ------------------------------------------------- Map.Entry<Integer,String> rsltMap3 = map.floorEntry(0); System.out.println(rsltMap3); // null |
実行例（ floorKey(K key) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(4, "four"); map.put(5, "five"); // 2以下の最大のキーの key を取得 Integer rsltKey1 = map.floorKey(2); System.out.println(rsltKey1); // 2 // 3以下の最大のキーの key を取得 Integer rsltKey2 = map.floorKey(3); System.out.println(rsltKey2); // 2 // 0以下の最大のキーの key を取得（該当するキーがないため、null が返ります） Integer rsltKey3 = map.floorKey(0); System.out.println(rsltKey3); // null |
3-3. higherEntry・higherKey
指定したキーより大きく最小のキーを取得することができます。
実行例（ higherEntry(K key) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // higherEntry // 2より大きい最小値を取得 Map.Entry<Integer,String> rsltMap1 = map.higherEntry(2); System.out.println(rsltMap1); // 3=three // 5より大きい最小値を取得（該当するキーがないため、null が返ります） Map.Entry<Integer,String> rsltMap2 = map.higherEntry(6); System.out.println(rsltMap2); // null |
実行例（ higherKey(K key) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // higherKey // 2より大きい最小値を取得 Integer rsltKey1 = map.higherKey(2); System.out.println(rsltKey1); // 3 // 5より大きい最小値を取得 Integer rsltKey3 = map.higherKey(6); System.out.println(rsltKey3); // null |
3-4. ceilingEntry・ceilingKey
指定したキー以上で最小のキーを取得することができます。
実行例（ ceilingEntry(K key) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(4, "four"); map.put(5, "five"); // 2以上の最小値を取得 Map.Entry<Integer,String> rsltMap1 = map.ceilingEntry(2); System.out.println(rsltMap1); // 2=two // 3以上の最小値を取得 Map.Entry<Integer,String> rsltMap2 = map.ceilingEntry(3); System.out.println(rsltMap2); // 4=four // 6以上の最小値を取得（該当するキーがないため、null が返ります） Map.Entry<Integer,String> rsltMap3 = map.ceilingEntry(6); System.out.println(rsltMap3); // null |
実行例（ ceilingKey(K key) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(4, "four"); map.put(5, "five"); // 2以上の最小値を取得 Integer rsltKey1 = map.ceilingKey(2); System.out.println(rsltKey1); // 2 // 3以上の最小値を取得 Integer rsltKey2 = map.ceilingKey(3); System.out.println(rsltKey2); // 4 // 6以上の最小値を取得 Integer rsltKey3 = map.ceilingKey(6); System.out.println(rsltKey3); // null |
4. Mapから指定した条件に該当する部分要素を取得
次のメソッドを使用します。
| メソッド | 戻り値 | 取得値（X） | 処理 |
|---|---|---|---|
| headMap (K toKey) |
SortedMap <K,V> |
key > X | 指定したキー未満の部分要素を取得します。 該当する要素が存在しない場合は、空のMapを返します。 |
| headMap (K toKey, boolean inclusive) |
NavigableMap <K,V> |
key > X key >= X |
第２引数に true を指定すると、指定したキー以下の部分要素を取得します。 該当する要素が存在しない場合は、空のMapを返します。 |
| subMap (K fromKey, K toKey) |
SortedMap <K,V> |
fkey <= X < toKey | 指定したfromKey以上かつ toKey未満の部分要素を取得します。 該当する要素が存在しない場合は、空のMapを返します。 |
| subMap (K fKey, boolean fInc, K tKey, boolean tInc) |
NavigableMap <K,V> |
fkey < X < toKey fkey <= X < toKey fkey < X <= toKey fkey <= X <= toKey |
指定したfromKey かつ toKey の部分要素を取得します。 第２、４引数を true にすると 以上・以下の条件にすることが出来ます。 該当する要素が存在しない場合は、空のMapを返します。 |
| tailMap (K fromKey) |
SortedMap <K,V> |
fkey <= X | 指定したキー以上の部分要素を取得します。 該当する要素が存在しない場合は、空のMapを返します。 |
| tailMap (K fromKey, boolean inc) |
NavigableMap <K,V> |
fkey < X fkey <= X |
第２引数に false を指定すると、指定したキーより大きい部分要素を取得します。 該当する要素が存在しない場合は、空のMapを返します。 |
4-1. headMap
指定したキー未満 もしくは キー以下の部分要素を取得できます。
実行例（ headMap(K toKey) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // 3未満のキーを持つ要素を取得 SortedMap<Integer,String> rsltMap1 = map.headMap(3); System.out.println(rsltMap1); // {1=one, 2=two} // 条件に一致した各要素にアクセス for( Map.Entry<Integer,String> parts : rsltMap1.entrySet() ) { System.out.println( parts.getKey() ); // key System.out.println( parts.getValue() ); // value } // 条件に一致しない場合は、空のMapを返します SortedMap<Integer,String> rsltMap2 = map.headMap(0); System.out.println(rsltMap2); // {} System.out.println(rsltMap2.size()); // 0 |
実行例（ headMap(K toKey, boolean inclusive) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // 3以下のキーを持つ要素を取得 NavigableMap<Integer,String> rsltMap1 = map.headMap(3, true); System.out.println(rsltMap1); // {1=one, 2=two, 3=three} // 条件に一致した各要素にアクセス for( Integer key : rsltMap1.keySet() ) { System.out.println( key ); // key System.out.println( rsltMap1.get(key) ); // value } // 条件に一致しない場合は、空のMapを返します NavigableMap<Integer,String> rsltMap2 = map.headMap(0, true); System.out.println(rsltMap2); // {} System.out.println(rsltMap2.size()); // 0 |
4-2. subMap
キーを範囲指定（from, to）して部分要素を取得することができます。
実行例（ subMap(K fromKey, K toKey) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // 1 <= x < 5 NavigableMap<Integer,String> resultMap3 = (NavigableMap<Integer, String>) map.subMap(1, 5); System.out.println(resultMap3); // {1=one, 2=two, 3=three, 4=four} // 以下の方法でも同じ結果になります NavigableMap<Integer,String> resultMap4 = map.subMap(1, true, 5, false); System.out.println(resultMap4); // {1=one, 2=two, 3=three, 4=four} |
実行例（ subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // 1 < x < 5 NavigableMap<Integer,String> resultMap1 = map.subMap(1, false, 5, false); System.out.println(resultMap1); // {2=two, 3=three, 4=four} // 1 <= x <= 5 NavigableMap<Integer,String> resultMap2 = map.subMap(1, true, 5, true); System.out.println(resultMap2); // {1=one, 2=two, 3=three, 4=four, 5=five} |
4-3. tailMap
指定したキーより大きい もしくは キー以上の部分要素を取得できます。
実行例（ tailMap(K fromKey) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // 3以上のキーを持つ要素を取得 SortedMap<Integer,String> rsltMap1 = map.tailMap(3); System.out.println(rsltMap1); // {3=three, 4=four, 5=five} // 条件に一致した各要素にアクセス for( Map.Entry<Integer,String> parts : rsltMap1.entrySet() ) { System.out.println( parts.getKey() ); // key System.out.println( parts.getValue() ); // value } // 条件に一致しない場合は、空のMapを返します SortedMap<Integer,String> rsltMap2 = map.tailMap(6); System.out.println(rsltMap2); // {} System.out.println(rsltMap2.size()); // 0 |
実行例（ tailMap(K fromKey, boolean inclusive) ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); map.put(4, "four"); map.put(5, "five"); // 3より大きいのキーを持つ要素を取得 NavigableMap<Integer,String> rsltMap1 = map.tailMap(3, false); System.out.println(rsltMap1); // {4=four, 5=five} // 条件に一致した各要素にアクセス for( Integer key : rsltMap1.keySet() ) { System.out.println( key ); // key System.out.println( rsltMap1.get(key) ); // value } // 条件に一致しない場合は、空のMapを返します NavigableMap<Integer,String> rsltMap2 = map.tailMap(5, false); System.out.println(rsltMap2); // {} System.out.println(rsltMap2.size()); // 0 |
5. Mapに格納されている要素を逆順で取得
次のメソッドを使用します。
| メソッド | 戻り値 | 処理 |
|---|---|---|
| descendingKeySet() | NavigableSet<K> | Mapに格納されている要素のキーを逆順で取得します。 |
| descendingMap() | NavigableMap<K,V> | Mapに格納されている要素を逆順で取得します。 |
実行例（ descendingKeySet() ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // キーを逆順で取得 NavigableSet<Integer> set = map.descendingKeySet(); System.out.println(set); // [3, 2, 1] Iterator<Integer> itr = set.iterator(); while( itr.hasNext() ) { System.out.println( itr.next() ); // 3 // 2 // 1 } |
実行例（ descendingMap() ）
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // キーの逆順で要素を取得 NavigableMap<Integer,String> rsltMap = map.descendingMap(); System.out.println( rsltMap ); // {3=three, 2=two, 1=one} for( Integer key : rsltMap.keySet() ) { System.out.println(key); // 3 // 2 // 1 } |
6. Mapに格納されている要素のkey一覧を取得
次のメソッドを使用します。
| メソッド | 戻り値 | 処理 |
|---|---|---|
| navigableKeySet() | NavigableSet<K> | Mapに格納されている要素のキーを取得します。 |
実行例
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
NavigableMap<Integer,String> map = new TreeMap<>(); map.put(1, "one"); map.put(2, "two"); map.put(3, "three"); // 全ての要素のキーを取得 NavigableSet<Integer> set = map.navigableKeySet(); System.out.println(set); // [1, 2, 3] Iterator<Integer> itr = set.iterator(); while( itr.hasNext() ) { System.out.println( itr.next() ); // 1 // 2 // 3 } |