Java HashMap

このチュートリアルでは、サンプルを使用してJava HashMapクラスおよびそのメソッドを学習します。

JavaコレクションフレームワークのHashMapクラスは提供Mapインターフェースのハッシュテーブル実装

HashMapを作成する

HashMapを作成するには、まずjava.util.HashMapパッケージをインポートする必要があります。パッケージをインポートすると、Javaでハッシュテーブルを作成できます。

//次のように作成する8の容量と0.6負荷因子的HashMap
HashMap<Key, Value> numbers = new HashMap<>();8, 0.6f);

上記のコードでは、numbersという名前のHashMapを作成しました。

ここでは、

• Key -マップの各要素（値）を一意に識別するために使用される

• 値 -マップに関連付けられた要素

请注意 new HashMap<>(8,0.6) 部分。这里，第一个参数是capacity，第二个参数是loadFactor。

• capacity - HashMap的容量为8。意味着，它可以存储8个条目。

• loadFactor -　 hashmap的负载因子为0.6。这意味着，每当哈希表被填满60%时，条目就会被移动到一个新哈希表，其大小是原始哈希表的两倍。

默认容量和负载因子

创建哈希表而不定义其容量和负载因子是允许的。例如，

//具有默认容量和负载因子的HashMap
HashMap<Key,　Value>　numbers1　=　new　HashMap<>();

默认，

• HashMap的容量将为 16

• 负载因子将为 0.75

从其他map创建HashMap

这是我们如何创建包含其他map的所有元素的HashMap的方法。

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建偶数的hashmap
　　　　　　　　HashMap<String,　Integer>　evenNumbers　=　new　HashMap<>();
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　System.out.println("HashMap1:　"　+　evenNumbers);
　　　　　　　　//从其他hashmap创建一个hashmap
　　　　　　　　HashMap<String,　Integer>　numbers　=　new　HashMap<>(evenNumbers);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap2:　"　+　numbers);
　　　　}
}

出力結果

HashMap1:　{Four=4,　Two=2}
HashMap2:　{Two=2,　Three=3,　Four=4}

HashMap的方法

本HashMap类提供各种方法，使我们能够在map上进行各种操作。

将元素插入HashMap

• put() - 将指定的键/值映射插入到map中

• putAll() - 将指定map的所有条目插入此map

• putIfAbsent() - 如果map中不存在指定的键，则将指定的键/值映射插入到map中

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建偶数HashMap
　　　　　　　　HashMap<String,　Integer>　evenNumbers　=　new　HashMap<>();
　　　　　　　　//　使用　put()
　　　　　　　　evenNumbers.put("Two",　2);
　　　　　　　　evenNumbers.put("Four",　4);
　　　　　　　　//　使用　putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six",　6);
　　　　　　　　System.out.println("偶数HashMap:　"　+　evenNumbers);
　　　　　　　　//Creating　HashMap　of　numbers
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　//　使用　putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("numbers的HashMap:　"}　+　numbers);
　　　　}
}

出力結果

偶数HashMap:　{Six=6,　Four=4,　Two=2}
numbers的HashMap:　{Six=6,　One=1,　Four=4,　Two=2}

访问HashMap元素

1.使用entrySet()，keySet()和values()

• entrySet() -返回一组所有键/值映射的map

• keySet() -返回map所有键的集合

• values() -返回map所有值的集合

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap:　"　+　numbers);
　　　　　　　　//　使用　entrySet()
　　　　　　　　System.out.println("Key/Value　映射:　"　+　numbers.entrySet());
　　　　　　　　//　使用　keySet()
　　　　　　　　System.out.println("Keys:　"　+　numbers.keySet());
　　　　　　　　//　使用　values()
　　　　　　　　System.out.println("Values:　"　+　numbers.values());
　　　　}
}

出力結果

HashMap:　{One=1,　Two=2,　Three=3}
Key/Value　映射:　[One=1,　Two=2,　Three=3]
Keys:　[One,　Two,　Three]
Values:　[1,　2,　3]

2.使用get()和getOrDefault()

• get() - 返回与指定键关联的值。如果找不到键，则返回null。

• getOrDefault() - 返回与指定键关联的值。如果找不到键，则返回指定的默认值。

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap:　"　+　numbers);
　　　　　　　　//　使用　get()
　　　　　　　　int　value1　=　numbers.get("Three");
　　　　　　　　System.out.println("返回数字:　"　+　value1);
　　　　　　　　//　使用　getOrDefault()
　　　　　　　　int　value2　=　numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("返回数字:　"　+　value2);
　　　　}
}

出力結果

HashMap:　{One=1,　Two=2,　Three=3}
返回数字:　3
返回数字:　5

删除元素

• remove(key)　 - 返回并从映射中删除与指定键相关联的项

• remove(key, value)　 - 仅当指定键映射到指定值并返回布尔值时，才从映射中删除该项

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap:　"　+　numbers);
　　　　　　　　//单个参数的删除方法
　　　　　　　　int　value　=　numbers.remove("Two");
　　　　　　　　System.out.println("删除值:　"　+　value);
　　　　　　　　//具有两个参数的删除方法
　　　　　　　　boolean　result　=　numbers.remove("Three",　3);
　　　　　　　　System.out.println("条目"3被删除了吗? "　+　result);
　　　　　　　　System.out.println("更新后的HashMap: ")　+　numbers);
　　　　}
}

出力結果

HashMap:　{One=1,　Two=2,　Three=3}
删除值:　2
条目3被删除了吗? True
更新后的HashMap: {One=1}

替换元素

• replace(key, value) - 将key的値替换为value

• replace(key, old, new) - 仅当old値已与指定键key关联时，才用new値替换old値

• replaceAll(function) - 用指定函数的结果替换映射的每个値

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　numbers.put("Third",　3);
　　　　　　　　System.out.println("原始HashMap: ")　+　numbers);
　　　　　　　　//　使用 replace()
　　　　　　　　numbers.replace("Second",　22);
　　　　　　　　numbers.replace("Third",　3,　33);
　　　　　　　　System.out.println("使用replace替换HashMap的値: ")　+　numbers);
　　　　　　　　//　使用 replaceAll()
　　　　　　　　numbers.replaceAll((key, oldValue)　->　oldValue　+　2);
　　　　　　　　System.out.println("使用replaceAll替换HashMap的値: ")　+　numbers);
　　　　}
}

出力結果

原始HashMap: {Second=2, Third=3,　First=1}
使用replace替换HashMap的値: {Second=22, Third=33,　First=1}
使用replaceAll替换HashMap的値: {Second=24, Third=35,　First=3}

在上述程序中，注意语句

numbers.replaceAll((key, oldValue)　->　oldValue　+　2);

在此，该方法访问map的所有条目。然后，它将所有値替换为ラムダ式提供的新値。

重新计算値

1.使用compute()方法

• compute() - 使用指定的函数计算新値。然后将计算値与指定的键相关联。

• computeIfAbsent() - 如果指定的键没有映射到任何値，该方法将使用指定的函数计算一个新値。然后将新值与键关联。

• computeIfPresent() -如果指定的键已经映射到任何值，此方法将使用指定的函数计算一个新值。然后将新值与键关联。

例如，

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　System.out.println("元のHashMap：　"　+　numbers);
　　　　　　　　//　使用 compute()
　　　　　　　　numbers.compute("First", (key, oldValue)　->　oldValue　+　2);
　　　　　　　　numbers.compute("Second", (key, oldValue)　->　oldValue　+　1);
　　　　　　　　System.out.println("HashMap 使用 compute(): ")　+　numbers);
　　　　　　　　//　computeIfAbsent()を使用して
　　　　　　　　numbers.computeIfAbsent("Three",　key　->　5);
　　　　　　　　System.out.println("HashMap　computeIfAbsent():　"　+　numbers);
　　　　　　　　//　computeIfPresent()を使用して
　　　　　　　　numbers.computeIfPresent("Second",　(key,　oldValue)　->　oldValue　*　2);
　　　　　　　　System.out.println("HashMap　computeIfPresent():　"　+　numbers);
　　　　}
}

出力結果

元のHashMap：　{Second=2,　First=1}
HashMap　compute():　{Second=3,　First=3}
HashMap　computeIfAbsent():　{Second=3　First=3,　Three=5}
HashMap　computeIfPresent():　{Second=6,　First=3,　three=5}

上記の例では、compute()メソッドを使用してマップの値を再計算しました。

ここでは、以下を使用しますラムダ式メソッドパラメータとして値を再計算します。

2.merge()メソッドを使用して

指定のキーがまだ関連していない場合、merge()メソッドは指定の値を指定のキーに関連付けます

ただし、指定のキーが既に値に関連している場合、新しい指定の値を現存する古い値と合計します。例えば

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("First",　1);
　　　　　　　　numbers.put("Second",　2);
　　　　　　　　System.out.println("元のHashMap：　"　+　numbers);
　　　　　　　　//　merge()メソッドを使用して
　　　　　　　　numbers.merge("First",　4,　(oldValue,　newValue)　->　oldValue　+　newValue);
　　　　　　　　System.out.println("新しいHashMap：　"　+　numbers);
　　　　}
}

出力結果

元のHashMap：　{Second=2,　First=1}
新しいHashMap：　{Second=2,　First=5}

上記の例では、merge()メソッドは以下を使用します3引数：key、newValueそして、ラムダ式（新しい合計値を計算するために使用）。

HashMapの他のメソッド

HashMapを遍历する

HashMapの中で、以下を行うことができます

• を遍历する キー

• を遍历する 値

• を遍历する キー/値

1.forEachループを使用

import java.util.HashMap;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//HashMapを作成
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap:　"　+　numbers);
　　　　　　　　//キーをアクセス/値（key/value）対
　　　　　　　　System.out.print("項目:　");
　　　　　　　　for(Entry<String,　Integer> entry: numbers.entrySet()) {
　　　　　　　　　　　　System.out.print(entry);
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//アクセス　key
　　　　　　　　System.out.print("\nすべてのキー:　");
　　　　　　　　for(String key: numbers.keySet()) {
　　　　　　　　　　　　System.out.print(key);
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//valueにアクセス
　　　　　　　　System.out.print("\nすべての値:　");
　　　　　　　　for(Integer value: numbers.values()) {
　　　　　　　　　　　　System.out.print(value);
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

出力結果

HashMap:　{One=1,　Two=2,　Three=3}
すべてのエントリー:　One=1,　Two=2,　Three=3
すべてのキー:　One,　Two,　Three,
すべての値:　1,　2,　,3,

上記のプログラムでは、java.util.Map.Entryパッケージをインポートしていることに注意してください。ここではMap.EntryはMapインターフェースの内包クラスです。

このネストされたクラスは、マップのビュー（要素）を返します。

2.iterator()メソッドを使用

iterator()メソッドを使用してHashMapを迭代することもできます。このメソッドを使用するには、java.util.Iteratorパッケージをインポートする必要があります。

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//HashMapを作成
　　　　　　　　HashMap<String,　Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap:　"　+　numbers);
　　　　　　　　//Iteratorのオブジェクトを作成
　　　　　　　　Iterator<Entry<String,　Integer>> iterate1　=　numbers.entrySet().iterator();
　　　　　　　　//　アクセス　Key/Value　対
　　　　　　　　System.out.print("すべてのエントリ:　");
　　　　　　　　while(iterate1.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate1.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//　アクセス　key
　　　　　　　　Iterator<String> iterate2　=　numbers.keySet().iterator();
　　　　　　　　System.out.print("\nすべてのキー:　");
　　　　　　　　while(iterate2.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate2.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//　valueにアクセス
　　　　　　　　Iterator<Integer>　iterate3　=　numbers.values().iterator();
　　　　　　　　　System.out.print("\nすべての値:　");
　　　　　　　　while(iterate3.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate3.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

出力結果

HashMap:　{One=1,　Two=2,　Three=3}
すべてのエントリー:　One=1,　Two=2,　Three=3
すべてのキー:　One,　Two,　Three,
すべての値:　1,　2,　3,

上記のプログラムでは、java.util.Map.Entry パッケージをインポートしました。ここでのMap.Entryは、Mapインターフェースのネストされたクラスです。

このネストされたクラスは、マップのビュー（要素）を返します。