【 Java 】HashMapの使いかた

## ■　はじめに
下記内容は、備忘録レベルで書いてますので間違い等あるかもしれません。
参考にする際にはその点ご認識のほどお願いします〜。。

## ■ 試した操作
<table>
  <thead>
    <tr>
      <th>メソッド</th> <th>詳細</th>
    </tr>
  </thead>
  <tr>
    <td>put()</td>
    <td>指定された値と指定されたキーをこのマップに関連付ける<br>
        マップが以前にこのキーのマッピングを保持していた場合、古い値が置き換えられる</td>
  </tr>
  <tr>
    <td>get()</td>
    <td>指定されたキーがマップされている値を返す<br>
        マップにそのキーのマッピングが含まれていない場合はnullを返す</td>
  </tr>
  <tr>
    <td>size()</td>
    <td>マップ内のキー値マッピングの数を返す</td>
  </tr>
  <tr>
    <td>putAll()</td>
    <td>指定されたマップからすべてのマッピングをマップにコピーする<br>
        マップが指定されたマップ内に現在あるキーのすべてに対して持っていたマッピングが置き換えられる</td>
  </tr>
  <tr>
    <td>remove()</td>
    <td>指定されたキーのマッピングがあればマップから削除する</td>
  </tr>
  <tr>
    <td>clear()</td>
    <td>すべてのマッピングをマップから削除する</td>
  </tr>
  <tr>
    <td>isEmpty()</td>
    <td>マップがキーと値のマッピングを保持しない場合にtrueを返す</td>
  </tr>
  <tr>
    <td>containsKey()</td>
    <td>指定のキーのマッピングがこのマップに含まれている場合にtrueを返す</td>
  </tr>
  <tr>
    <td>containsValue()</td>
    <td>このマップが1つまたは複数のキーを指定された値にマッピングしている場合にtrueを返す</td>
  </tr>
  <tr>
    <td>keySet()</td>
    <td>マップに含まれるキーのSetビューを返す</td>
  </tr>
  <tr>
    <td>entrySet()</td>
    <td>マップに含まれるマッピングのSetビューを返す</td>
  </tr>
  <tr>
    <td>forEach()</td>
    <td>マップのすべてのエントリの処理が完了するかアクションから例外がスローされるまで、各エントリに対して指定されたアクションを実行する</td>
  </tr>
  <tr>
    <td>DeepCopy<br>※メソッド名ではない</td>
    <td>キーと値をコピーする</td>
  </tr>
  <tr>
    <td>ShallowCopy<br>※メソッド名ではない</td>
    <td>キーと値を参照する</td>
  </tr>
</table>

## ■ put()
```java
    /**
     * put()を使ってキーと値をマッピングする
     * 第一引数にInteger、第二引数にStringを渡す
     */
    
    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2,"Two");
    hashMap.put(3, "Four");
    
    hashMap.put(3, "Three");
    hashMap.put(4,"Four");
    hashMap.put(5, "Five");

    // hashMap内のエントリを全て表示する
    hashMap.forEach((key,value) -> {
    	System.out.println(key + "：" + value );
	});

/** 
    表示結果 
    ※キー「3」は重複するため、値が置き換えられる
     キー「4,5」は重複しないため新規追加される

     1：One
     2：Two
     3：Three
     4：Four
     5：Five
 */
```
## ■ get()
```java
    /**
     * get()を使い、キーにマッピングされた値を取得する
     * キー「1」は挿入されているため値を取得することができる
     *　　キー[2]は挿入されていないため「null」が返ってくる
     */
    
    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");

    // get()でマッピングされている値を取得
    System.out.println(hashMap.get(1)); // One
	System.out.println(hashMap.get(2)); // null
```
## ■ size()
```java
    /**
     * size()を使い、キー値マッピングの数を取得する
     * 3つマッピングしたため、3が返ってくる
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    
    System.out.println(hashMap.size()); // 3
```
## ■ putAll()
```java
    /**
     * putAll()を使い、すべてのマッピングをマップにコピーする
     * すでにキーがあれば、値は置き換えられる
     */
    
    // HashMap初期化
    Map<Integer,String> firstMap = new HashMap<>();
    Map<Integer,String> copyMap = new HashMap<>();
    
    // キーと値を挿入
    firstMap.put(1, "One");
    firstMap.put(2, "Two");
    firstMap.put(3, "Four");
    
    // firstMapのマッピングをcopyMapにコピーする
    copyMap.putAll(firstMap);
    copyMap.forEach((key,value) -> {
        System.out.println(key + "：" + value );
    });
    
    // HashMap初期化
    Map<Integer,String> secondMap = new HashMap<>();
    
    // キーと値を挿入
    secondMap.put(1, "One");
    secondMap.put(2, "Two");
    secondMap.put(3, "Three");
    
    // secondMapのマッピングをcopyMapにコピーする
    copyMap.putAll(secondMap);
    copyMap.forEach((key,value) -> {
        System.out.println(key + "：" + value );
    });

/** 
    表示結果 
    ※copyMapにはfirstMapとsecondMapのマッピングがコピーされている
     キー「3」は重複するため、値が置き換えられる

    firstMapコピー後のマッピング 
    　1：One
    　2：Two
    　3：Four

    secondMapコピー後のマッピング
    　1：One
    　2：Two
    　3：Three
 */
```
## ■ remove()
```java
    /**
     * remove()を使い、指定されたキーのマッピングがあればマップから削除する
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
        
    System.out.println(hashMap); // {1=One, 2=Two}
    
    // キー「2」のマッピングを削除
    hashMap.remove(2);
    System.out.println(hashMap); // {1=One}
```
## ■ clear()
```java
    /**
     * clear()を使い、すべてのマッピングをマップから削除する
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    
    System.out.println(hashMap); // {1=One, 2=Two, 3=Three}
    
    // hashMapのマッピングを全て削除する
    hashMap.clear();
    System.out.println(hashMap); // {}
```
## ■ isEmpty()
```java
    /**
     * isEmpty()を使い、マッピングを保持しているか判定する
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    
    // hashMapはマッピングを保持しているため「false」を返す
    System.out.println(hashMap.isEmpty()); // false
    
    // マッピングを全て削除したことで、hashMapはマッピングを保持していないため「true」を返す
    hashMap.clear();
    System.out.println(hashMap.isEmpty()); // true
```
## ■ containsKey(), containsValue()
```java
    /**
     * containsKey()を使い、引数に渡された値がキーにあるか判定する
     * containsValue()を使い、引数に渡された値が値にあるか判定する
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    
    // キー「1」は挿入されているため「true」を、キー「4」は挿入されていないため「false」を返す
    System.out.println(hashMap.containsKey(1)); // true
    System.out.println(hashMap.containsKey(4)); // false

    // 値「One」は挿入されているため「true」を、値「Four」は挿入されていないため「false」を返す
    System.out.println(hashMap.containsValue("One")); // true
    System.out.println(hashMap.containsValue("Four")); // false
```
## ■ keySet()
```java
    /**
     * keySet()を使い、マップに含まれるキーのSetビューを取得する
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    
    // エントリー内のキーを取得できる
    System.out.println(hashMap.keySet()); // [1, 2, 3]
    
    // 取得したキーをもとに、値を取得する
    for (Integer key: hashMap.keySet()) {
        System.out.println(hashMap.get(key));
    }

/** 
    表示結果
     One
     Two
     Three
 */
```
## ■ entrySet()
```java
    /**
     * entrySet()を使い、マップに含まれるマッピングのSetビューを取得する
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");
    
    // エントリー内のキーと値のセットを取得できる
    System.out.println(hashMap.entrySet()); // [1=One, 2=Two, 3=Three]

```
## ■ forEach()
```java
    /**
     * forEach()を使い、マップのすべてのエントリの処理を実行する
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");

    // エントリー内のキーとセットを全て出力
    hashMap.forEach((key,value) -> {
        System.out.println(key + "：" + value );
    });

/** 
    表示結果
     1：One
    　　2：Two
    　　3：Three
 */

```
## ■ DeepCopy
```java:DeepCopy
    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2,"Two");
    hashMap.put(3, "Four");
    
    // 変更前
    hashMap.forEach((key,value) -> {
        System.out.println(key + "：" + value );
    });
    
    // キーと値をコピー
    Map<Integer,String> deepHashMap = new HashMap<>(hashMap);

    // hashMapの値を書き換える
	hashMap.put(3, "Three");

    // deepHashMap内のエントリを全て表示する
    deepHashMap.forEach((key,value) -> {
    	System.out.println(key + "：" + value );
	});

/** 
    表示結果 
    ※hashMapの値を変更してもdeepHashMapには影響がないことが確認できる

    変更前
    1：One
    2：Two
    3：Four
    
    変更後 
    1：One
    2：Two
    3：Four
 */
```
## ■ ShallowCopy
```java:ShallowCopy
    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2,"Two");
    hashMap.put(3, "Four");
    
    // 変更前
    hashMap.forEach((key,value) -> {
        System.out.println(key + "：" + value );
    });
    
    // キーと値をコピー
    Map<Integer,String> shallowHashMap = hashMap;

    // hashMapの値を書き換える
    hashMap.put(3, "Three");

    // shallowHashMap内のエントリを全て表示する
    shallowHashMap.forEach((key,value) -> {
        System.out.println(key + "：" + value );
    });

/** 
    表示結果 
    ※hashMapの値を変更するとshallowHashMapの値も変わっていることが確認できる

    変更前
    1：One
    2：Two
    3：Four
    
    変更後 
    1：One
    2：Two
    3：Three
 */
```

## ■ 番外　Mapのいろんなループ方法
```java
    /**
     * ① keySet()を使った場合
     * ② entrySet()を使った場合
     * ③ forEach文を使った場合
     */

    // HashMap初期化
    Map<Integer,String> hashMap = new HashMap<>();
    
    // キーと値を挿入
    hashMap.put(1, "One");
    hashMap.put(2, "Two");
    hashMap.put(3, "Three");

    // ① keySet()を使った場合
    for (Integer key : hashMap.keySet()) {
		System.out.println(key + " : " + hashMap.get(key));
    }
    
    // ② entrySet()を使った場合
    for (Map.Entry<Integer, String> entry : hashMap.entrySet()) {
      System.out.println(entry.getKey() + " : " + entry.getValue());
    }
    
    // ③ forEach文を使った場合
    hashMap.forEach((key,value) -> {
        System.out.println(key + " : " + value );
    });

/**
    表示結果
    ※表示結果は①~③全て同じ
    　　1 : One
    　　2 : Two
    　　3 : Three
    
 */
```

## ■ 参照

https://docs.oracle.com/javase/jp/8/docs/api/java/util/HashMap.html#clone--

https://magazine.techacademy.jp/magazine/34900

https://magazine.techacademy.jp/magazine/35791