Java `HashMap`

原文： https://www.programiz.com/java-programming/hashmap

在本教程中，我们将借助示例学习 Java `HashMap`类及其方法。

Java 集合框架的HashMap类提供Map接口的哈希表实现。

创建一个`HashMap`

为了创建哈希映射，我们必须首先导入java.util.HashMap包。导入包后，就可以使用 Java 创建哈希映射。

// HashMap creation with 8 capacity and 0.6 load factor
HashMap<Key, Value> numbers = new HashMap<>(8, 0.6f);

在上面的代码中，我们创建了一个名为number的哈希映射。

这里，

Key - 用于关联映射中每个元素（值）的唯一标识符
Value - 映射中与按键相关联的元素

注意部分new HashMap<>(8, 0.6)。在此，第一个参数是capcity，第二个参数是loadFactor。

capcity-此哈希映射的容量为 8。意味着，它可以存储 8 个条目。
loadFactor -此哈希映射的负载因子为 0.6。这意味着，只要我们的哈希表填充了 60%，条目就会移到新哈希表中，其大小是原始哈希表的两倍。

默认容量和负载系数

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

// HashMap with default capacity and load factor
HashMap<Key, Value> numbers1 = new HashMap<>();

默认，

哈希映射的容量将为 16
负载系数将为 0.75

从其他映射创建`HashMap`

这是我们如何创建包含其他映射的所有元素的哈希映射的方法。

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // Creating a hashmap of even numbers
        HashMap<String, Integer> evenNumbers = new HashMap<>();
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);
        System.out.println("HashMap1: " + evenNumbers);

        // Creating a hash map from other 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类提供了各种方法，可让我们在映射上执行各种操作。

将元素插入`HashMap`

put() - 将指定的键/值映射插入到映射中
putAll() - 将指定映射中的所有条目插入此映射中
putIfAbsent() - 如果映射中不存在指定的键，则将指定的键/值映射插入到映射中

例如，

import java.util.HashMap;

class Main {
    public static void main(String[] args) {
        // Creating HashMap of even numbers
        HashMap<String, Integer> evenNumbers = new HashMap<>();

        // Using put()
        evenNumbers.put("Two", 2);
        evenNumbers.put("Four", 4);

        // Using putIfAbsent()
        evenNumbers.putIfAbsent("Six", 6);
        System.out.println("HashMap of even numbers: " + evenNumbers);

        //Creating HashMap of numbers
        HashMap<String, Integer> numbers = new HashMap<>();
        numbers.put("One", 1);

        // Using putAll()
        numbers.putAll(evenNumbers);
        System.out.println("HashMap of numbers: " + numbers);
    }
}

输出：

HashMap of even numbers: {Six=6, Four=4, Two=2}
HashMap of numbers: {Six=6, One=1, Four=4, Two=2}

访问`HashMap`元素

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

entrySet() - 返回一组所有键/值映射的映射
keySet() - 返回映射的所有键的集合
values() - 返回一组所有映射值

例如：

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);

        // Using entrySet()
        System.out.println("Key/Value mappings: " + numbers.entrySet());

        // Using keySet()
        System.out.println("Keys: " + numbers.keySet());

        // Using values()
        System.out.println("Values: " + numbers.values());
    }
}

输出：

HashMap: {One=1, Two=2, Three=3}
Key/Value mappings: [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);

        // Using get()
        int value1 = numbers.get("Three");
        System.out.println("Returned Number: " + value1);

        // Using getOrDefault()
        int value2 = numbers.getOrDefault("Five", 5);
        System.out.println("Returned Number: " + value2);
    }
}

输出：

HashMap: {One=1, Two=2, Three=3}
Returned Number: 3
Returned Number: 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);

        // remove method with single parameter
        int value = numbers.remove("Two");
        System.out.println("Removed value: " + value);

        // remove method with two parameters
        boolean result = numbers.remove("Three", 3);
        System.out.println("Is the entry Three removed? " + result);

        System.out.println("Updated HashMap: " + numbers);
    }
}

输出：

HashMap: {One=1, Two=2, Three=3}
Removed value: 2
Is the entry Three removed? True
Updated HashMap: {One=1}

替换元素

replace(key, value) - 用新的value替换与指定的key相关的值
replace(key, old, new) - 仅当old值已与指定的key关联时，才用new值替换old值。
replaceAll(function) - 用指定的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("Original HashMap: " + numbers);

        // Using replace()
        numbers.replace("Second", 22);
        numbers.replace("Third", 3, 33);
        System.out.println("HashMap using replace(): " + numbers);

        // Using replaceAll()
        numbers.replaceAll((key, oldValue) -> oldValue + 2);
        System.out.println("HashMap using replaceAll(): " + numbers);
    }
}

输出：

Original HashMap: {Second=2, Third=3, First=1}
HashMap using replace: {Second=22, Third=33, First=1}
HashMap using replaceAll: {Second=24, Third=35, First=3}

在上述程序中，声明

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

在此，该方法访问映射的所有条目。然后，它将所有值替换为 lambda 表达式提供的新值。

重新计算值

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("Original HashMap: " + numbers);

        // Using compute()
        numbers.compute("First", (key, oldValue) -> oldValue + 2);
        numbers.compute("Second", (key, oldValue) -> oldValue + 1);
        System.out.println("HashMap using compute(): " + numbers);

        // Using computeIfAbsent()
        numbers.computeIfAbsent("Three", key -> 5);
        System.out.println("HashMap using computeIfAbsent(): " + numbers);

        // Using computeIfPresent()
        numbers.computeIfPresent("Second", (key, oldValue) -> oldValue * 2);
        System.out.println("HashMap using computeIfPresent(): " + numbers);
    }
}

输出：

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

在上面的示例中，我们使用compute()方法重新计算了映射的值。

在这里，我们使用 lambda 表达式作为方法参数来重新计算值。

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("Original HashMap: " + numbers);

        // Using merge() Method
        numbers.merge("First", 4, (oldValue, newValue) -> oldValue + newValue);
        System.out.println("New HashMap: " + numbers);
    }
}

输出：

Original HashMap: {Second=2, First=1}
New HashMap: {Second=2, First=5}

在上面的示例中，merge()方法采用 3 个参数：key，newValue和 lambda 表达式（用于计算新的合并值）。

`HashMap`的其他方法

方法	描述
`clear()`	从映射中删除所有条目
`containsKey()`	检查映射是否包含指定的键并返回布尔值
`containsValue()`	检查映射是否包含指定的值并返回布尔值
`size()`	返回映射的大小
`isEmpty()`	检查映射是否为空并返回布尔值

迭代`HashMap`

在HashMap中，我们可以

遍历其键
遍历其值
遍历其键/值

1.使用forEach循环

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

class Main {
    public static void main(String[] args) {

        // Creating a HashMap
        HashMap<String, Integer> numbers = new HashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("HashMap: " + numbers);

        // Accessing the key/value pair
        System.out.print("Entries: ");
        for(Entry<String, Integer> entry: numbers.entrySet()) {
            System.out.print(entry);
            System.out.print(", ");
        }

        // Accessing the key
        System.out.print("\nKeys: ");
        for(String key: numbers.keySet()) {
            System.out.print(key);
            System.out.print(", ");
        }

        // Accessing the value
        System.out.print("\nValues: ");
        for(Integer value: numbers.values()) {
            System.out.print(value);
            System.out.print(", ");
        }
    }
}

输出：

HashMap: {One=1, Two=2, Three=3}
Entries: One=1, Two=2, Three=3
Keys: One, Two, Three,
Values: 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) {
        // Creating a HashMap
        HashMap<String, Integer> numbers = new HashMap<>();
        numbers.put("One", 1);
        numbers.put("Two", 2);
        numbers.put("Three", 3);
        System.out.println("HashMap: " + numbers);

        // Creating an object of Iterator
        Iterator<Entry<String, Integer>> iterate1 = numbers.entrySet().iterator();

        // Accessing the Key/Value pair
        System.out.print("Entries: ");
        while(iterate1.hasNext()) {
            System.out.print(iterate1.next());
            System.out.print(", ");
        }

        // Accessing the key
        Iterator<String> iterate2 = numbers.keySet().iterator();
        System.out.print("\nKeys: ");
        while(iterate2.hasNext()) {
            System.out.print(iterate2.next());
            System.out.print(", ");
        }

        // Accessing the value
        Iterator<Integer> iterate3 = numbers.values().iterator();
         System.out.print("\nValues: ");
        while(iterate3.hasNext()) {
            System.out.print(iterate3.next());
            System.out.print(", ");
        }
    }
}

输出：

HashMap: {One=1, Two=2, Three=3}
Entries: One=1, Two=2, Three=3
Keys: One, Two, Three,
Values: 1, 2, 3,

在上面的程序中， note that we have imported the java.util.Map.Entry package. Here, Map.Entry is the nested class of the Map interface.

This nested class returns a view (elements) of the map.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Java `HashMap`

在本教程中，我们将借助示例学习 Java `HashMap`类及其方法。

创建一个`HashMap`

从其他映射创建`HashMap`

`HashMap`的方法

将元素插入`HashMap`

访问`HashMap`元素

删除元素

替换元素

重新计算值

`HashMap`的其他方法

迭代`HashMap`

Uh oh!

FilesExpand file tree

77.md

Latest commit

History

77.md

File metadata and controls

Java HashMap

在本教程中，我们将借助示例学习 Java HashMap类及其方法。

创建一个HashMap

从其他映射创建HashMap

HashMap的方法

将元素插入HashMap

访问HashMap元素

删除元素

替换元素

重新计算值

HashMap的其他方法

迭代HashMap

Java `HashMap`

在本教程中，我们将借助示例学习 Java `HashMap`类及其方法。

创建一个`HashMap`

从其他映射创建`HashMap`

`HashMap`的方法

将元素插入`HashMap`

访问`HashMap`元素

`HashMap`的其他方法

迭代`HashMap`