Java 菜鸟教程

Java 流程控制

Java 数组

Java 面向对象(I)

Java 面向对象(II)

Java 面向对象(III)

Java 异常处理

Java 列表(List)

Java Queue(队列)

Java Map集合

Java Set集合

Java 输入输出(I/O)

Java Reader/Writer

Java 其他主题

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 -用于关联map中每个元素(值)的唯一标识符

  • Value -map中与键相关联的元素

请注意 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的所有条目。然后,它将所有值替换为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("原始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()方法重新计算了映射的值。

在这里,我们使用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("原始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个参数:keynewValue和一个lambda表达式(用于计算新的合并值)。

HashMap的其他方法

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

遍历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接口的嵌套类。

该嵌套类返回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接口的嵌套类。

该嵌套类返回map的视图(元素)。