Java
2021.12.02
JavaのMap型とは?初期化やループ処理の書き方&便利なメソッドまとめ
2021.12.02

1.JavaのMapとは?

Mapとは、「キー」と対応する「値」の2つの要素をペアにして格納するデータ構造です。キーを値に「マッピング」、すなわち対応付けるのでMapと呼ばれています。

① Mapを使うメリット

Mapを使うメリットは、「キー」を使って処理ができることです。Listや配列にはキーが無く、インデックス番号によって要素にアクセスしますが、Mapではキーを指定することで値にアクセスできます。


「apple」というキーを「リンゴ」という値に対応付けたり、「banana」というキーを「バナナ」に対応付けたりといったように、キーに意味を持たせることでListや配列などとは違う使い方ができるのです。

② HashMapとは?Mapとの違い

Mapとの違いがわかりづらいものに、「HashMap」があります。HashMapとは、インタフェースを実装するクラスのことです。


Mapはインタフェースなので、そのままでは使えません。そのため実装クラスを自作するか、Mapインタフェースの実装クラスであるHashMap、LinkedHashMap、TreeMapなどを使用する必要があります。


HashMapは、その中でも多く使われている一般的な実装クラスです。

2.Mapの基本的な使い方


ここではMapのルール、宣言・初期化方法など、基本的な使い方を見ていきましょう。

①基本ルール

前述のとおり、Mapには「キー」と「値」がペアとして格納されます。つまりひとつのキーをひとつの値に対応させなければいけないので、キーが重複してはいけません。

②Mapの宣言・初期化方法

HashMapを使ってMapの宣言、初期化を行ってみます。


宣言の際の構文は以下の通りです。

Map<キーのデータ型, 値のデータ型> マップ名 = new HashMap<>();

これにならって実際に宣言をしてみましょう。

import java.util.HashMap;   // importが必要
import java.util.Map;

public class Java_map {
    public static void main(String[] args) {
        Map<String, String> exMap = new HashMap<>();  // Mapの宣言
    }
}

キーと値両方のデータ型がStringの「exMap」というMapが宣言できました。このとき、java.util.HashMapとjava.util.Mapのインポートが必要なことに気をつけてください。


続いて初期化です。


初期化の際は、Mapのputメソッドを使って以下のように要素を追加します。

マップ名.put(キー, 値);

実際に初期化してみましょう。

import java.util.HashMap;   //importが必要
import java.util.Map;

public class Java_map {
    public static void main(String[] args) {
        Map<String, String> exMap = new HashMap<>();  // Mapの宣言
        exMap.put("apple", "リンゴ");
        exMap.put("banana", "バナナ");
        exMap.put("orange", "オレンジ");
    }
}

キーに英単語、値に日本語を指定して3つの要素を追加しました。


または、以下のように宣言、初期化を同時に行う方法もあります。

// importなど省略
Map<String, String> exMap = new HashMap<String, String>() { // Mapの宣言、初期化
    {
        put("apple", "リンゴ");
        put("banana", "バナナ");
        put("orange", "オレンジ");
    }
};

この場合はダイアモンド演算子が使えない、すなわちHashMapのデータ型が省略できません。型名の記述を忘れないようにしましょう。


3.ループを使ったMapへのアクセス


Mapの要素にアクセスしたいときにはループを使います。具体的にどのようにしてループ処理を行うのかを見ていきましょう。

①Iteratorを使ったfor文

まずはIteratorを使ったfor文で、Mapの要素にアクセスしてみます。


MapはそのままではIteratorを使用できません。使用する場合は、メソッドを介してIteratorが使えるインタフェースに変更する必要があります。


まずはサンプルコードを見てみましょう。下の例はkeySetメソッドを使った場合です。

import java.util.HashMap;
import java.util.Map;
import java.util.Iterator; // Iteratorのimportを忘れずに

public class Java_map {
    public static void main(String[] args) {
        Map<String, String> exMap = new HashMap<>(); // Mapの宣言
        exMap.put("apple", "リンゴ"); 
        exMap.put("banana", "バナナ");
        exMap.put("orange", "オレンジ");
        for (Iterator<String> itr = exMap.keySet().iterator(); itr.hasNext();) {
            String key = itr.next();
            System.out.println(key);
        }
    }
}

出力:

banana
orange
apple

exMap.keySet()では、exMapに含まれるキーの一覧がSetインタフェースとして返ってきます。SetインタフェースはCollectionを継承しておりIteratorが使えるため、この返り値に対して.iterator()でIteratorを取得しています。そのあとは通常通り、Iteratorのメソッドを使ってfor文を書くだけです。


出力の部分を下のようにすれば、キーと値を合わせて表示できます。

System.out.println(key + " : " + exMap.get(key));

出力:

banana : バナナ
orange : オレンジ
apple : リンゴ

次にvaluesメソッドを使った場合を示します。

// for文だけ
for (Iterator<String> itr = exMap.values().iterator(); itr.hasNext();) {
    String val = itr.next();
    System.out.println(val);
}

出力:

バナナ
オレンジ
リンゴ

exMap.values()とすることで、exMapに含まれる値の一覧がCollectionとして返ってきます。CollectionインタフェースはIteratorを使えるインタフェースです。Setインタフェースはこれを継承しているため、Iteratorが使えます。


最後にentrySetメソッドを使った例を見てみましょう。

// for文だけ
for (Iterator<Map.Entry<String, String>> itr = exMap.entrySet().iterator(); itr.hasNext();) {
    Map.Entry<String, String> entry = itr.next();
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

出力:

banana : バナナ
orange : オレンジ
apple : リンゴ

exMap.entrySet()では、キーと値の組の一覧がSetインタフェースとして返ってきます。keySet()のときと同じように、Setインタフェースである返り値に対してIteratorを取得しています。getKeyメソッドはキーを取得、getValueメソッドは値を取得できる、Map.Entryのメソッドです。


ここまでで、MapでIteratorを使ってfor文を回す方法にはいくつかパターンがあることがわかりました。状況に応じて使い分けましょう。

②forEachメソッドとラムダ式

次はforEachメソッドでMapにアクセスしてみます。

ラムダ式を使ったforEachメソッドの構文は以下の通りです。

コレクション名.forEach(引数 -> 繰り返し処理);

それではサンプルコードを見てみましょう。

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

public class Java_map {
    public static void main(String[] args) {
        Map<String, String> exMap = new HashMap<>(); // Mapの宣言
        exMap.put("apple", "リンゴ"); // Mapの初期化
        exMap.put("banana", "バナナ");
        exMap.put("orange", "オレンジ");
        exMap.forEach((key, val) -> System.out.println(key + " : " + val));
    }
}

出力:

banana : バナナ
orange : オレンジ
apple : リンゴ

これまで通りMapの宣言、初期化をし、forEachメソッドを使っています。ただし、Mapの場合は引数がキーと値の2つ存在するので、必ず(キー, 値)の形で変数名を記述しましょう。変数がひとつだけだとエラーが発生してしまいます。


また、以下のようにkeyのみの出力もできます。

// forEach部分だけ
exMap.forEach((key, val) -> System.out.println(key));

出力:

banana
orange
apple



4.MapでStream APIを利用する方法


Stream APIはとても便利ですが、MapはCollectionインタフェースを実装していないので、使うためにひと手間必要です。どう使用するのか知っておきましょう。

①そもそもStream APIとは?

Stream APIとは、Java8から導入されたAPIです。コレクションなどをStreamに変換し、それに対して様々な処理を行えます。

操作の大まかな流れとしては、下記です。

  1. コレクションなどをストリームに変換
  2. 中間操作(map, filterなど)を行う
  3. 終端操作(forEachなど)を行う

中間操作のmapはStreamに対して使えるメソッドのことです。今回扱っているデータ構造のMapとは別のものなので注意してください。

②Stream APIの使い方

流れに沿ってStream APIを使ってみましょう。まずは、filterメソッドを使ってMapから一部の要素を取り出したいと思います。

import java.util.HashMap;
import java.util.Map;
import java.util.stream.Stream; // Streamのimportを忘れずに
public class Java_map {
    public static void main(String[] args) {
        Map<String, String> exMap = new HashMap<>(); // Mapの宣言
        exMap.put("apple", "リンゴ"); // Mapの初期化
        exMap.put("banana", "バナナ");
        exMap.put("orange", "オレンジ");

        exMap.entrySet().stream()   // 1. Mapをstreamに変換
                .filter(map -> "apple".equals(map.getKey()))    // 2. 中間操作(今回はfilter)
                .forEach(map -> System.out.println(map.getKey() + " : " + map.getValue())); // 3. 終端操作(今回はforEach)
    }
}

その際、Streamのimportを忘れずに行いましょう。


まずはMapをStreamに変換します。これまでも何度かお伝えした通り、MapはCollectionインタフェースを継承していません。Streamに変換する前に、Collectionインタフェース、またはそれを継承するListやSetなどのインタフェースに変換が必要です。


そのため、Mapのキーと値を同時に取り出すためにentrySet()でSetインタフェースに変換し、さらにstream()でStreamに変換をしています。


次に中間操作を行います。今回はfilterメソッドによって、キーが”apple”である要素だけを抽出しました。

最後はforEachメソッドで終端操作をしています。


先ほど説明したforEachの書き方と、今回のforEachの書き方が違うことがわかります。

Mapに直接forEachを使う場合は、下のように引数が(キー, 値)の形でした。

exMap.forEach((key, val) -> System.out.println(key + " : " + val));

今回のforEachでは、引数はmapのひとつだけです。

.forEach(map -> System.out.println(map.getKey() + " : " + map.getValue()));

今回はMapをStreamに変換したためこのような記述になっています。Streamに変換した際は、Streamの引数をひとつ取り、その中にあるMapのキー、値をメソッドで取り出します。


Mapを扱うときとMapを変換したStreamを扱うとき、2つのパターンを混同しないように気をつけましょう。


操作の流れはいつも同じなので、Streamのメソッドがわかれば簡単にStream APIを使えます。ぜひ様々な操作を行ってみてください。


5.Mapのよく使うメソッド

Mapに対して操作を行う際、必要不可欠なのがメソッドです。forEachやStream APIを扱うときにも、Mapのメソッドが一緒に使われていました。中でもよく使うメソッドを紹介します。

①データの追加に関するメソッド

putメソッドでデータを追加

putメソッドはキーと値のセットのデータをMapに追加します。使い方は下記の通りです。

Map名.put(キー, 値);

実際に使う例を示します。

Map<String, String> putMap = new HashMap<>(); // Mapの宣言
putMap.put("apple", "リンゴ"); // Mapの初期化
putMap.put("apple", "りんご"); // "りんご"に置き換わる
putMap.put("banana");    // エラー発生
putMap.put("オレンジ");  // エラー発生

注意すべきは「既に追加されているキー」と「違う値」のセットを追加したとき、キーに対応させる値が新しく追加した値に置き換わることです。上の例なら、”apple”というキーに対応させる値は”リンゴ”からひらがなの”りんご”に代わりました。


また、要素を初期化する際、引数がひとつだとエラーが発生してしまうので、必ずキーと値をセットで追加するように気をつけてください。


putメソッドは初期化で必ず使うメソッドです。しっかり覚えておきましょう。

②データの取得に関するメソッド

getメソッドでデータを取得

getメソッドは、指定したキーに対応する値を取得できます。

Map名.get(キー);

実際に使う例を示します。

Map<String, String> exMap = new HashMap<>(); // Mapの宣言
exMap.put("apple", "リンゴ"); // Mapの初期化
exMap.put("banana", "バナナ");
exMap.put("orange", "オレンジ");

System.out.println(exMap.get("apple")); // getメソッド
System.out.println(exMap.get("banana"));
System.out.println(exMap.get("orange"));
System.out.println(exMap.get("kiwi"));  // 存在しないキー

出力:

リンゴ
バナナ
オレンジ
null

存在しないキーを指定するとnullが返ってきます。


keySetメソッドでMapのすべてのキーを取得

keySetメソッドは、マップに含まれるすべてのキーを取得できます。

Map名.keySet();

すべてのキーを実際に取得してみます。

// Mapの宣言、初期化は省略
System.out.println(exMap.keySet());	// keySetメソッド

出力:

[banana, orange, apple]

keySetメソッドで返ってくるのはキーを要素に持ったSetです。Iteratorを扱った際にもkeySetメソッドを使っているので、ぜひ見返してみてください。


valuesメソッドでMapの値をすべて取得

valuesメソッドは、Mapのすべての値を取得できます。

Map名.values();

全ての値を取得してみましょう。

// Mapの宣言、初期化は省略
System.out.println(exMap.values());	// valuesメソッド

出力:

[バナナ, オレンジ, リンゴ]

keySetメソッドとは違い、valuesメソッドではすべての値が入ったコレクションが返ってきます。valuesメソッドもIteratorを扱う際に使いました。


entrySetでMapが持つキー・値をすべて取得

keySet, valuesは片方のみでしたが、entrySetメソッドはキーと値を一度にすべて取得できます。

exMap.entrySet();

entrySetメソッドでキーと値を取得します。

// Mapの宣言、初期化は省略
System.out.println(exMap.entrySet());
/*拡張for文を使って出力*/
Set<Map.Entry<String, String>> entry = exMap.entrySet();
for (Map.Entry<String, String> e : entry) {
    System.out.println(e.getKey() + " : " + e.getValue());
}

出力:

[banana=バナナ, orange=オレンジ, apple=リンゴ]
banana : バナナ
orange : オレンジ
apple : リンゴ

Iteratorを扱う時にentrySetメソッドを使用しましたが、実はIteratorを使わずにfor文を使えます。今回は拡張for文を使って、entrySetメソッドで取得したSetに対して繰り返し処理を行っています。


entrySetはIteratorだけでなくStream APIを扱うときにも使いました。Setに変換する際によく使われるので、覚えておきましょう。


sizeメソッドでデータの数を取得

sizeメソッドはMapに含まれるキーと値のセットの数を取得できます。

Map名.size();

実際に使ってみましょう。

System.out.println(exMap.size()); 

出力:

3

exMapは(“apple”, “リンゴ”) 、(“banana”, “バナナ”)、(“orange”, “オレンジ”)の3つのセットが要素なので、sizeメソッドは3を返します。

③データの検索に関するメソッド

containsKeyでキーがあるか確認

containsKeyメソッドを使えば、Mapにキーが存在するか確認できます。

Map名.containsKey(キー);

このメソッドは指定したキーが存在すればtrue、存在しなければfalseを返します。実際に使ってみましょう。

// Mapの宣言、初期化は省略
System.out.println(exMap.containsKey("apple")); // 存在するキー
System.out.println(exMap.containsKey("kiwi"));  // 存在しないキー

出力:

true
false

“apple”はexMapに存在するキーなのでtrue、”kiwi”は存在しないキーなのでfalseが返ってきます。


containsValueで値があるか確認

containsValueはMapに指定した値が存在するかを確認できます。

Map名.containsValue(値);

実際に使用すると下記のようになります。

// Mapの宣言、初期化は省略
System.out.println(exMap.containsValue("リンゴ"));  // 存在する値
System.out.println(exMap.containsValue("キウイ"));  // 存在しない値

出力:

true
false

先ほどと同じように、返ってくる値はbooleanです。”リンゴ”は存在するのでtrue、”キウイ”は存在しないのでfalseとなります。


Arrays.sortでソート

Arrays.sortは、名前からわかる通りArraysのsortメソッドです。つまり、Arraysのimportが必要であり、Mapのキーを配列に変換する必要があります。変換した配列に対して下記のようにメソッドが使えます。

Arrays.sort(配列);

配列に変換するという性質上、Arrays.sortメソッドはキーでソートするときに使われます。実際にキーでソートを行ってみます。

// java.util.Arrays のimportが必要
/* ソート前 */
System.out.println("ソート前");
exMap.forEach((key, val) -> System.out.println(key + " : " + val)); // ソート前を出力

/* ソート */
Object[] keysArray = exMap.keySet().toArray(); // Mapのキーを配列に変換
Arrays.sort(keysArray); // Arrays.sort
System.out.println("ソート後");
Arrays.asList(keysArray).forEach(key -> System.out.println(key + " : " + exMap.get(key)));

出力:

ソート前
banana : バナナ
orange : オレンジ
apple : リンゴ
ソート後
apple : リンゴ
banana : バナナ
orange : オレンジ

まずjava.util.Arrays のimportを忘れないようにしましょう。次にkeySetメソッドで取得したキーをtoArrayメソッドで配列へ変換し、この配列に対してArrays.sortメソッドを使いソートを行います。


ここで、Arrays.sortは昇順にソートを行うことに気をつけましょう。降順でソートを行いたいときには、下記のように引数を追加します。

Arrays.sort(配列, Collections.reverseOrder());

今回はArrays.sortを紹介しましたが、ソートの方法はこれだけではありません。様々なメソッドがありますので、目的に応じて他にも調べてみてください。

④データの削除に関するメソッド

removeメソッドで要素を削除

removeメソッドで、指定したキーの要素が削除できます。

Map名.remove(キー);

実際に削除してみましょう。

exMap.remove("apple");  // remove
exMap.forEach((key, val) -> System.out.println(key + " : " + val));

出力:

banana : バナナ
orange : オレンジ

キーが”apple”である、(“apple”, “リンゴ”)の要素が削除されました。


clearメソッドですべての要素を削除

clearメソッドは、キーなどの指定なくすべての要素を削除できます。

Map名.clear();

全ての要素を実際に削除してみます。

exMap.clear();	// clear
exMap.forEach((key, val) -> System.out.println(key + " : " + val));

出力:

なし

出力がないことからもわかるように、Mapの要素がすべて削除され、このMapは空になりました。Map自体は残っているので、またputメソッドを使って要素を追加することもできます。


6.Map・List・Setの違いと特徴


初めに、ここでは「コレクション」とCollectionインタフェースを区別していることに気を付けてください。


Map・List・Set はすべてコレクションですが、それぞれに違いがあります。一番大きな違いは、MapのみがCollectionインタフェースを継承していないことです。


IteratorやStream APIを操作したときに何回かお伝えしましたが、Collectionインタフェースに対して行える操作は、そのままではMapに行えません。


それぞれのコレクションの代表的な違いを表にしました。

 MapListSet
Collectionの継承なしありあり
要素の重複なしありなし
自動ソートクラスにより異なるなしクラスにより異なる
順序クラスにより異なるありクラスにより異なる
主な実装クラスHashMap, TreeMap, LinkedHashMapArrayList, LinkedListHashSet, TreeSet, LinkedHashSet

Collectionインタフェースの継承については先ほどお伝えした通りです。要素の重複に関して、Mapの要素とはキーと値のセットとして書いているため重複なしとしました。つまり、キーが異なれば、値は重複していても構いません。


順序は、Listでは保存され、MapとSetは実装するクラスによって異なります。例えば、今回使ったHashMapは順序を保存しないクラスです。

①Listとは

ListはCollectionインタフェースを継承するコレクションで、挿入順に要素が格納されます。同じ要素を追加してもインデックスやリンクが違うため、要素の重複が可能です。


Listの実装クラスにはArrayListやLinkedListがあります。ArrayListは要素にインデックスを持たせ、そのインデックスから要素にアクセスするような構造です。LinkedListは要素同士が前後に持つリンクでつながっているため、アクセスに時間がかかります。

②Setとは

Setは、Collectionインタフェースを継承する集合のコレクションです。そのため重複は認められず、基本のHashSetクラスでは自動ソート、順序などはありません。TreeSetクラスを使えば要素が自動ソートされ、LinkedHashSetを使えば挿入の順序が保たれます。


7.Mapとその他のコレクション・オブジェクトとの変換方法


最後に、Mapとその他のコレクション・オブジェクトとの変換方法を3つ紹介します。

①ListとMapの変換

まずはMapのキー、値をListに変換していきます。

import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList; // ArrayListのimportを忘れずに
import java.util.List;      // Listのimportを忘れずに
public class Java_map {
    public static void main(String[] args) {
        Map<String, String> exMap = new HashMap<>(); // Mapの宣言
        exMap.put("apple", "リンゴ"); // Mapの初期化
        exMap.put("banana", "バナナ");
        exMap.put("orange", "オレンジ");
        List<String> keyList = new ArrayList<>(exMap.keySet());     // キーをListに変換
        List<String> valueList = new ArrayList<>(exMap.values());   // 値をListに変換
        System.out.println(keyList);
        System.out.println(valueList);
    }
}

出力:

[banana, orange, apple]
[バナナ, オレンジ, リンゴ]

今回はArrayListを使うので、ListとArrayListのimportを忘れずに行いましょう。

Listへの変換はkeySetメソッド、valuesメソッドでキーと値を取得しListに変換する、という形で行いました。


次にListをMapに変換してみましょう。

// importなど省略
List<String> keyMList = new ArrayList<>(); // Listの宣言
keyMList.add("apple"); // Listの初期化
keyMList.add("banana");
keyMList.add("orange");
List<String> valMList = new ArrayList<>(); // Listの宣言
valMList.add("リンゴ"); // Listの初期化
valMList.add("バナナ");
valMList.add("オレンジ");

Map<String, String> LMap = new HashMap<>();
for (int i = 0; i < keyMList.size(); i++) {
    LMap.put(keyMList.get(i), valMList.get(i));
}
System.out.println(LMap);

出力:

{banana=バナナ, orange=オレンジ, apple=リンゴ}

キーを持つリストと値を持つリストの要素をfor文で順番に追加していきました。要素数が同じでないとすべてを追加できないので気をつけてください。

②SetとMapの変換

MapからSetへの変換は、Mapのメソッドを使用すれば簡単にできます。

import java.util.HashMap;
import java.util.Map;
import java.util.HashSet; // HashSetのimportを忘れずに
import java.util.Set; // Setのimportを忘れずに
public class Java_map {
    public static void main(String[] args) {
        Map<String, String> exMap = new HashMap<>(); // Mapの宣言
        exMap.put("apple", "リンゴ"); // Mapの初期化
        exMap.put("banana", "バナナ");
        exMap.put("orange", "オレンジ");
	      Set<String> keySet = new HashSet<>(exMap.keySet()); // keySetメソッド
        Set<String> valSet = new HashSet<>(exMap.values()); // valuesメソッド
        Set<Map.Entry<String, String>> entrySet = exMap.entrySet(); // entrySetメソッド
        System.out.println(keySet);
        System.out.println(valSet);
        System.out.println(entrySet);
    }
}

出力:

[banana, orange, apple]
[リンゴ, オレンジ, バナナ]
[banana=バナナ, orange=オレンジ, apple=リンゴ]

keySetメソッド、entrySetメソッドを使ってSetを生成しました。valuesメソッドは実際にはコレクションが返ってきますが、そのままSetに変換しています。


次にSetをMapに変換します。

import java.util.LinkedHashSet; // LinkedHashSetのimportを忘れずに
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Java_map {
    public static void main(String[] args) {
        Set<String> keyMSet = new LinkedHashSet<>(); // Setの宣言
        keyMSet.add("apple"); // Setの初期化
        keyMSet.add("banana");
        keyMSet.add("orange");

        Set<String> valMSet = new LinkedHashSet<>(); // Setの宣言
        valMSet.add("リンゴ"); // Setの初期化
        valMSet.add("バナナ");
        valMSet.add("オレンジ");

        Map<String, String> SMap = new HashMap<>();
        for (Iterator<String> keyItr = keyMSet.iterator(); keyItr.hasNext();) {
            for (Iterator<String> valItr = valMSet.iterator(); valItr.hasNext();) {
                SMap.put(keyItr.next(), valItr.next());
            }
        }
        System.out.println("SMap");
        System.out.println(SMap);
    }
}

出力:

{banana=バナナ, orange=オレンジ, apple=リンゴ}

Iteratorを使った入れ子のfor文で、Setの要素をMapに追加しました。アイデアはListからMapへの変換と同じです。ただし今回は挿入順を保存するため、HashSetではなくLinkedHashSetを使用していることに注意してください。


例えばHashSetでは、挿入(add)の順番が保存されず、以下のような順番になります。

キー:[banana, orange, apple]

値:[リンゴ, オレンジ, バナナ]


この順番のままMapに入れると次のようになり、キーと値の対応が元のMapと変わってしまうのです。


{banana=リンゴ, orange=オレンジ, apple=バナナ}


このため、LinkedHashSetを使いキーと値の順番を一致させています。挿入の順番が保存されるかどうかは非常に重要ですので、どのクラスで初期化をするか、用途に合わせて判断しましょう。

③jsonとMapの変換

JSONはJavaScriptのデータフォーマットであり、Mapと似た形で{“キー”:”値”}のペアで定義します。

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;

public class Java_map {
    public static void main(String[] args) {
        Map<String, String> exMap = new HashMap<>(); // Mapの宣言
        exMap.put("apple", "リンゴ"); // Mapの初期化
        exMap.put("banana", "バナナ");
        exMap.put("orange", "オレンジ");
	      /*MapからJSON*/
	      String exJson = "";
        ObjectMapper objectMapper = new ObjectMapper(); // インスタンス化
        try {
            exJson = objectMapper.writeValueAsString(exMap);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("exJson");
        System.out.println(exJson);

	      /*JSONからMap*/
	      String MJson = "{\"apple\":\"リンゴ\",\"banana\":\"バナナ\",\"orange\":\"オレンジ\"}";
        Map<String, String> JMap = new HashMap<String, String>();
        try {
            JMap = objectMapper.readValue(MJson, new TypeReference<HashMap<String, String>>(){});
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("JMap");
        System.out.println(JMap);
    }
}

出力:

exJson
{"banana": "バナナ", "orange":” "オレンジ", "apple": "リンゴ"}
JMap
{banana=バナナ, orange=オレンジ, apple=リンゴ}

JSONとMapの変換は上記のようになります。形式が似ているため、複雑な処理は必要ありません。JSONのインストール方法などはここでは説明しませんが、よく使うデータ形式なので覚えておきましょう。


8.プログラミング学習ならトレノキャンプへ


トレノキャンプでは、Javaを実践的に学ぶためのコースをオンラインで提供しています。オンデマンド配信なので、いつでも好きなときに受講が可能です。講座の詳しい内容は下記のバナーをクリックしてご覧ください。

この記事をシェア
おすすめの受講コース
  • Javaエンジニア完全パック -実務に必要なスキルを網羅-
  • はじめてのデータベース ~仕組みの理解とSQL~
  • Javaプログラミング本格入門シリーズ①~データ構造とアルゴリズム~
  • Javaで学習するユニットテスト入門 ~JUnitで理解するテスト手法~