Java 中 Map 集合

wuilwxxxxx

242人浏览 · 2026-03-08 20:09:06

wuilwxxxxx · 2026-03-08 20:09:06 发布

一、Map 基础认知（先建立概念）

Map 是 Java 中用于存储键值对（Key-Value） 的集合，核心特点：

键（Key）唯一，不能重复；值（Value）可以重复。
常用实现类：HashMap（最常用，无序）、TreeMap（按 Key 排序）、LinkedHashMap（按插入顺序）。
入门先以 HashMap 为例，因为它是日常开发中使用频率最高的。

二、Map 常用方法（从易到难）

1. 基础操作（入门级）

方法	作用	示例
`put(K key, V value)`	添加 / 修改键值对（Key 存在则覆盖 Value）	`map.put("name", "张三");`
`get(Object key)`	根据 Key 获取 Value，Key 不存在返回`null`	`String name = map.get("name");`
`size()`	获取键值对数量	`int len = map.size();`
`isEmpty()`	判断是否为空	`boolean empty = map.isEmpty();`
`containsKey(Object key)`	判断是否包含指定 Key	`boolean hasName = map.containsKey("name");`
`containsValue(Object value)`	判断是否包含指定 Value	`boolean hasZhang = map.containsValue("张三");`
`remove(Object key)`	根据 Key 删除键值对，返回被删除的 Value	`String delValue = map.remove("name");`
`clear()`	清空所有键值对	`map.clear();`

基础示例代码：

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

public class MapBasicMethod {
    public static void main(String[] args) {
        // 1. 创建HashMap对象（泛型指定Key为String，Value为String）
        Map<String, String> userMap = new HashMap<>();

        // 2. 添加键值对
        userMap.put("name", "张三");
        userMap.put("age", "20");
        userMap.put("gender", "男");

        // 3. 基础查询
        System.out.println("获取name的值：" + userMap.get("name")); // 输出：张三
        System.out.println("Map大小：" + userMap.size()); // 输出：3
        System.out.println("是否包含key=age：" + userMap.containsKey("age")); // 输出：true
        System.out.println("是否包含value=20：" + userMap.containsValue("20")); // 输出：true

        // 4. 修改（Key存在则覆盖）
        userMap.put("age", "21");
        System.out.println("修改后的age：" + userMap.get("age")); // 输出：21

        // 5. 删除
        userMap.remove("gender");
        System.out.println("删除后大小：" + userMap.size()); // 输出：2

        // 6. 清空
        userMap.clear();
        System.out.println("清空后是否为空：" + userMap.isEmpty()); // 输出：true
    }
}

2. 进阶操作（中级）

方法	作用	示例
`putIfAbsent(K key, V value)`	仅当 Key 不存在时添加，避免覆盖	`map.putIfAbsent("name", "李四");`
`getOrDefault(Object key, V defaultValue)`	获取 Value，Key 不存在返回默认值	`String addr = map.getOrDefault("addr", "未知");`
`replace(K key, V value)`	仅当 Key 存在时修改 Value	`map.replace("age", "22");`
`replace(K key, V oldValue, V newValue)`	仅当 Key 和旧 Value 都匹配时修改	`map.replace("age", "21", "22");`
`keySet()`	获取所有 Key 的集合（Set）	`Set<String> keys = map.keySet();`
`values()`	获取所有 Value 的集合（Collection）	`Collection<String> values = map.values();`
`entrySet()`	获取所有键值对的集合（Set<Map.Entry<K,V>>）	`Set<Map.Entry<String,String>> entries = map.entrySet();`

进阶示例代码：

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

public class MapAdvancedMethod {
    public static void main(String[] args) {
        Map<String, String> userMap = new HashMap<>();
        userMap.put("name", "张三");
        userMap.put("age", "20");

        // 1. putIfAbsent：Key存在则不添加
        userMap.putIfAbsent("name", "李四"); // name已存在，不会覆盖
        System.out.println("putIfAbsent后的name：" + userMap.get("name")); // 输出：张三

        // 2. getOrDefault：Key不存在返回默认值
        String addr = userMap.getOrDefault("addr", "北京市");
        System.out.println("地址：" + addr); // 输出：北京市

        // 3. replace：精准修改
        userMap.replace("age", "21"); // 直接修改age的值
        userMap.replace("age", "21", "22"); // 仅当age=21时修改为22
        System.out.println("replace后的age：" + userMap.get("age")); // 输出：22

        // 4. 获取所有Key
        Set<String> keys = userMap.keySet();
        System.out.println("所有Key：" + keys); // 输出：[name, age]

        // 5. 获取所有Value
        Collection<String> values = userMap.values();
        System.out.println("所有Value：" + values); // 输出：[张三, 22]

        // 6. 获取所有键值对（Entry）
        Set<Map.Entry<String, String>> entries = userMap.entrySet();
        System.out.println("所有键值对：" + entries); // 输出：[name=张三, age=22]
    }
}

3. 高级操作（Java 8+ 特性，偏难）

Java 8 为 Map 新增了一批基于 Lambda 的方法，简化复杂操作：

方法	作用	示例
`forEach(BiConsumer<? super K,? super V> action)`	遍历所有键值对（Lambda 版）	`map.forEach((k,v) -> System.out.println(k+":"+v));`
`compute(K key, BiFunction<? super K,? super V,? extends V> remappingFunction)`	根据 Key 和旧 Value 计算新 Value	`map.compute("age", (k,v) -> String.valueOf(Integer.parseInt(v)+1));`
`merge(K key, V value, BiFunction<? super V,? super V,? extends V> remappingFunction)`	合并 Key 的 Value（Key 不存在则添加，存在则按规则合并）	`map.merge("score", "80", (oldV, newV) -> String.valueOf(Integer.parseInt(oldV)+Integer.parseInt(newV)));`

高级示例代码：

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

public class MapJava8Method {
    public static void main(String[] args) {
        Map<String, String> userMap = new HashMap<>();
        userMap.put("name", "张三");
        userMap.put("age", "20");
        userMap.put("score", "70");

        // 1. forEach遍历（Lambda）
        System.out.println("forEach遍历：");
        userMap.forEach((key, value) -> System.out.println(key + "=" + value));

        // 2. compute：修改Value（age+1）
        userMap.compute("age", (k, v) -> {
            if (v == null) return "0";
            return String.valueOf(Integer.parseInt(v) + 1);
        });
        System.out.println("compute后的age：" + userMap.get("age")); // 输出：21

        // 3. merge：合并Value（score=70+10=80）
        userMap.merge("score", "10", (oldV, newV) -> 
            String.valueOf(Integer.parseInt(oldV) + Integer.parseInt(newV))
        );
        System.out.println("merge后的score：" + userMap.get("score")); // 输出：80
    }
}

三、Map 遍历方式（从易到难）

1. 方式 1：遍历 Key，再通过 Key 获取 Value（入门级）

最简单的遍历方式，适合只需要 Key 或通过 Key 查 Value 的场景：

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

public class MapTraverse1 {
    public static void main(String[] args) {
        Map<String, String> userMap = new HashMap<>();
        userMap.put("name", "张三");
        userMap.put("age", "20");
        userMap.put("gender", "男");

        // 1. 获取所有Key的Set集合
        Set<String> keys = userMap.keySet();
        // 2. 遍历Key
        for (String key : keys) {
            // 3. 通过Key获取Value
            String value = userMap.get(key);
            System.out.println(key + "=" + value);
        }
    }
}

缺点：如果需要同时获取 Key 和 Value，每次get(key)会额外查询，效率略低。

2. 方式 2：遍历 Value（仅需 Value 时用，入门级）

只能获取 Value，无法获取对应的 Key，适合只关注 Value 的场景：

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

public class MapTraverse2 {
    public static void main(String[] args) {
        Map<String, String> userMap = new HashMap<>();
        userMap.put("name", "张三");
        userMap.put("age", "20");

        // 1. 获取所有Value的Collection集合
        Collection<String> values = userMap.values();
        // 2. 遍历Value
        for (String value : values) {
            System.out.println(value);
        }
    }
}

缺点：丢失 Key 信息，适用场景有限。

3. 方式 3：遍历 EntrySet（中级，推荐）

直接遍历键值对（Entry），一次获取 Key 和 Value，效率最高，日常开发首选：

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

public class MapTraverse3 {
    public static void main(String[] args) {
        Map<String, String> userMap = new HashMap<>();
        userMap.put("name", "张三");
        userMap.put("age", "20");

        // 1. 获取所有Entry的Set集合
        Set<Map.Entry<String, String>> entries = userMap.entrySet();
        // 2. 遍历Entry
        for (Map.Entry<String, String> entry : entries) {
            // 3. 获取Key和Value
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }
    }
}

优点：效率高，能同时获取 Key 和 Value，是最常用的遍历方式。

4. 方式 4：Iterator 迭代器遍历（中级，支持删除）

遍历过程中可以安全删除元素（foreach 遍历中删除会抛异常）：

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

public class MapTraverse4 {
    public static void main(String[] args) {
        Map<String, String> userMap = new HashMap<>();
        userMap.put("name", "张三");
        userMap.put("age", "20");
        userMap.put("gender", "男");

        // 1. 获取EntrySet的迭代器
        Set<Map.Entry<String, String>> entries = userMap.entrySet();
        Iterator<Map.Entry<String, String>> iterator = entries.iterator();

        // 2. 遍历
        while (iterator.hasNext()) {
            Map.Entry<String, String> entry = iterator.next();
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);

            // 3. 安全删除（比如删除gender）
            if ("gender".equals(key)) {
                iterator.remove();
            }
        }
        System.out.println("删除后大小：" + userMap.size()); // 输出：2
    }
}

优点：遍历中可安全删除元素；缺点：代码稍繁琐。

https://edu.csdn.net/learn/39067/627173?utm_source=2019755004

汇聚全球AI编程工具，助力开发者即刻编程。

更多推荐

3分钟掌握Codex技能安装：一键部署你的AI助手工具库

想要为你的Codex AI助手安装新技能？不用再手动复制文件了！skill-installer为你提供了一套完整的解决方案，让你能够从GitHub仓库快速获取和安装各种实用的Codex技能。无论你是AI开发新手还是经验丰富的开发者，这个工具都能让你在几分钟内扩展Codex的功能边界。## 为什么选择skill-installer？ 🤔在AI辅助编程的时代，Codex技能已经成为提升开发效

AI编程社区

DB-GPT分布式AI数据引擎：企业级智能分析平台架构解析

DB-GPT作为新一代AI数据助手，通过分布式架构和智能代理引擎重构了传统数据分析范式。该平台将大型语言模型的自然语言理解能力与企业级数据处理需求深度融合，构建了面向生产环境的可扩展AI数据平台。其核心价值在于将复杂的SQL生成、数据分析和可视化任务转化为简单的自然语言交互，同时确保系统安全性、可追溯性和企业级可靠性。## 技术定位与生态分析在当前数据智能生态中，DB-GPT填补了传统BI

AI编程社区

如何用Awesome Claude Skills将AI助手打造成你的全能创作伙伴和职业顾问

你是否曾想过，如果有一个AI伙伴能帮你完成从专业文章撰写到完美简历定制的所有工作，工作效率会提升多少倍？Awesome Claude Skills正是这样一个神奇的AI技能宝库，它汇集了1000+个精心筛选的Claude技能，覆盖内容创作、职业发展、文档处理等各个方面，让你在AI的帮助下轻松应对各种工作挑战。## 痛点分析：传统工作流程的三大瓶颈在内容创作和职业发展中，我们常常面临这样的困