《掌握这些，Java HashMap 性能飙升！原理、方法与应用场景深度剖析》-优快云博客

本文链接：https://blog.youkuaiyun.com/big___tree/article/details/147311755

一、HashMap 基础概念

HashMap 是 Java 集合框架的重要成员，它实现了 Map 接口，以散列表的形式存储键值对。其内部通过哈希函数将键映射到特定的存储位置，从而实现快速查找。它允许最多一个键为 null，并且不支持线程同步，适用于单线程环境下对查找速度要求较高的场景。同时，HashMap 是无序的，不会保留元素插入的顺序。

二、HashMap 常用方法详解及实例

（一）添加元素

put(K key, V value)：用于将指定的键值对添加到 HashMap 中。如果键已存在，则替换其对应的值。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);
        System.out.println(map);
    }
}

输出结果：{two=2, three=3, one=1}

putAll(Map<? extends K,? extends V> m)：将指定 Map 中的所有键值对添加到当前 HashMap 中。

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

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map1 = new HashMap<>();
        map1.put("one", 1);
        map1.put("two", 2);

        HashMap<String, Integer> map2 = new HashMap<>();
        map2.put("three", 3);
        map2.put("four", 4);

        map1.putAll(map2);
        System.out.println(map1);
    }
}

输出结果：{two=2, four=4, three=3, one=1}

putIfAbsent(K key, V value)：仅当指定的键在 HashMap 中不存在时，才将键值对插入。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.putIfAbsent("one", 11); // 因为"one"已存在，不会插入新值
        map.putIfAbsent("two", 2);
        System.out.println(map);
    }
}

输出结果：{two=2, one=1}

（二）获取元素

get(Object key)：返回指定键所映射的值，如果键不存在则返回 null。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        System.out.println(map.get("one")); // 输出1
        System.out.println(map.get("five")); // 输出null
    }
}

getOrDefault(Object key, V defaultValue)：返回指定键所映射的值，如果键不存在，则返回指定的默认值。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        System.out.println(map.getOrDefault("one", 0)); // 输出1
        System.out.println(map.getOrDefault("five", 5)); // 输出5
    }
}

（三）删除元素

remove(Object key)：从 HashMap 中移除指定键的映射关系，如果键存在则返回其对应的值，否则返回 null。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        System.out.println(map.remove("one")); // 输出1
        System.out.println(map.remove("two")); // 输出null
        System.out.println(map);
    }
}

输出结果：{}

clear()：移除 HashMap 中的所有键值对，使其变为空集合。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.clear();
        System.out.println(map);
    }
}

输出结果：{}

（四）判断元素是否存在

containsKey(Object key)：检查 HashMap 中是否存在指定键的映射关系。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        System.out.println(map.containsKey("one")); // 输出true
        System.out.println(map.containsKey("two")); // 输出false
    }
}

containsValue(Object value)：检查 HashMap 中是否存在指定值的映射关系。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        System.out.println(map.containsValue(1)); // 输出true
        System.out.println(map.containsValue(2)); // 输出false
    }
}

（五）其他常用方法

size()：返回 HashMap 中键值对的数量。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        System.out.println(map.size()); // 输出2
    }
}

isEmpty()：判断 HashMap 是否为空，即是否不包含任何键值对。

import java.util.HashMap;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        System.out.println(map.isEmpty()); // 输出true
        map.put("one", 1);
        System.out.println(map.isEmpty()); // 输出false
    }
}

keySet()：返回一个包含 HashMap 中所有键的 Set 集合视图。

import java.util.HashMap;
import java.util.Set;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key);
        }
    }
}

输出结果：

two
one

values()：返回一个包含 HashMap 中所有值的 Collection 集合视图。

import java.util.HashMap;
import java.util.Collection;

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        Collection<Integer> values = map.values();
        for (Integer value : values) {
            System.out.println(value);
        }
    }
}

输出结果：

2
1

entrySet()：返回一个包含 HashMap 中所有键值对的 Set 集合视图，每个元素都是一个 Map.Entry 对象。

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

public class HashMapExample {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        Set<Map.Entry<String, Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

输出结果：

two : 2
one : 1

三、HashMap 常用方法排名

根据实际使用频率和重要性，以下是对 HashMap 常用方法的大致排名：

put(K key, V value)：添加键值对是 HashMap 的基本操作，使用频率极高，常用于构建数据集合。
get(Object key)：获取指定键对应的值，是 HashMap 查找功能的核心方法，在需要根据键获取数据的场景中经常使用。
size()：用于获取 HashMap 中元素的数量，在统计数据量的场景中十分常用。
containsKey(Object key)：判断指定键是否存在，在进行数据校验、避免重复插入等场景中经常用到。
keySet() / values() / entrySet()：用于遍历 HashMap，在需要对集合中的键、值或键值对进行批量处理时使用。
remove(Object key)：删除指定键的映射关系，在需要从集合中移除特定数据时使用。
putAll(Map<? extends K,? extends V> m)：一次性添加多个键值对，适用于快速初始化或合并两个 HashMap 的场景。
putIfAbsent(K key, V value)：在避免重复插入相同键的场景中较为实用，能简化代码逻辑。
getOrDefault(Object key, V defaultValue)：在获取值时提供默认值，可避免空指针异常，常用于需要设置默认值的场景。

四、HashMap 的使用场景

（一）缓存数据

在开发中，经常需要缓存一些数据以提高系统性能。例如，在 Web 应用中，可以使用 HashMap 缓存数据库查询结果。当用户频繁请求相同数据时，先从 HashMap 中查找，如果存在则直接返回，避免重复查询数据库，从而大大提高响应速度。

import java.util.HashMap;

public class DataCache {
    private static HashMap<Integer, String> cache = new HashMap<>();

    public static String getDataFromCache(int key) {
        return cache.get(key);
    }

    public static void setDataToCache(int key, String value) {
        cache.put(key, value);
    }
}

（二）统计元素出现次数

在文本处理、数据分析等场景中，需要统计某个元素出现的次数。HashMap 可以将元素作为键，出现次数作为值，方便地实现统计功能。

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

public class WordCount {
    public static void main(String[] args) {
        String text = "apple banana apple orange banana apple";
        String[] words = text.split(" ");
        HashMap<String, Integer> wordCountMap = new HashMap<>();

        for (String word : words) {
            wordCountMap.put(word, wordCountMap.getOrDefault(word, 0) + 1);
        }

        for (Map.Entry<String, Integer> entry : wordCountMap.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

输出结果：

apple : 3
banana : 2
orange : 1

（三）存储配置信息

在应用程序中，常常需要存储和读取配置信息。HashMap 可以将配置项的名称作为键，配置值作为值，方便地管理配置信息。

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

public class Configuration {
    private static HashMap<String, String> config = new HashMap<>();

    public static void setConfig(String key, String value) {
        config.put(key, value);
    }

    public static String getConfig(String key) {
        return config.get(key);
    }
}

五、总结

HashMap 作为 Java 集合框架中的重要成员，提供了丰富且实用的方法，适用于多种开发场景。通过深入理解其原理、掌握常用方法及应用场景，开发者可以更加高效地利用 HashMap 解决实际问题，提升程序的性能和可维护性。在实际开发中，应根据具体需求合理选择和使用 HashMap 的方法，充分发挥其优势，构建出更加健壮和高效的软件系统。