Java基础知识之Map

原创 已于 2023-10-08 15:13:19 修改 · 1w 阅读 · 103 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #servlet

于 2023-03-22 20:20:01 首次发布
本文介绍了Map接口的基本概念和特性，包括它作为双列数据结构存储键值对的特性，以及HashMap和TreeMap的常见用法。文章详细讲解了Map的常用方法，如put()添加数据，remove()删除数据，clear()清空数据，containsKey()和containsValue()检查键或值是否存在，isEmpty()判断是否为空，get()获取键对应的值，以及keySet()获取所有键的集合。此外，还展示了如何遍历Map，包括使用keySet()和entrySet()方法，并通过案例展示了Map存储和遍历学生对象的情况。

文章目录

一、Map介绍

Map是用于保存具有映射关系的数据集合，它具有双列存储的特点，即一次必须添加两个元素，即一组键值对==><Key,Value>，其中Key的值不可重复（当Key的值重复的时候，后面插入的对象会将之前插入的具有相同的Key值的对象覆盖掉），Value的值可重复。Map作为接口，它最常见的实现类是HashMap和TreeMap，作为接口它抽取了所有实现类的共有方法。同时Map不具有带索引的方法，因此无法使用普通for循环来遍历Map集合

其中<Key,Value>键值对，在Java语言中又被称之为Entry/entry，Map.Entry就相当于Student.name，若name的数据类型为String，则Student.name的数据类型为String，同理若<key,value>中key的数据类型为Integer，value的数据类型为String，则Map.Entry的数据类型为<Integer,String>。

接下来我们将结合代码来具体学习Map相关知识。

二、Map的常用方法 Map应知应会

Map作为接口，它最常见的实现类是HashMap和TreeMap，作为接口它抽取了所有实现类的共有方法，所有实现Map接口的实现类均可使用这些方法。例如HashMap和TreeMap均可使用如下共有方法。

方法名说明
V put(K key,V value)增添数据
V remove(Object Key)根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsValue(Object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
V get(Object key)()根据键获取值
Set keySet()获取所有键集合

2.1 调用put()方法增添数据

具体实现类为HashMap的Map

public static void main(String[] args) {
        //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
        //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
        Map<Integer,String> map=new HashMap<>();
        //调用put()方法增添数据
        map.put(18,"aaa");
        map.put(20,"bbb");
        map.put(19,"ccc");
        //输出数据
        System.out.println(map);
    }

运行结果：
在这里插入图片描述

具体实现类为TreeMap的Map

public static void main(String[] args) {
        //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
        //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
        Map<Integer,String> map=new TreeMap<>();
        //调用put()方法增添数据
        map.put(18,"aaa");
        map.put(20,"bbb");
        map.put(19,"ccc");
        //输出数据
        System.out.println(map);
    }

运行结果：
在这里插入图片描述

2.2 调用remove()方法删除数据

接下来我们以具体实现类为HashMap的Map来举例

public static void main(String[] args) {
        //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
        //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
        Map<Integer,String> map=new HashMap<>();
        //调用put()方法增添数据
        map.put(18,"aaa");
        map.put(20,"bbb");
        map.put(19,"ccc");
        //调用remove()方法删除数据
        map.remove(18);
        //输出数据
        System.out.println(map);
    }

运行结果：
在这里插入图片描述

2.3 调用clear()方法清空数据

public static void main(String[] args) {
        //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
        //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
        Map<Integer,String> map=new HashMap<>();
        //调用put()方法增添数据
        map.put(18,"aaa");
        map.put(20,"bbb");
        map.put(19,"ccc");
        map.put(20,"ddd");
        map.put(21,"eee");
        //调用clear()方法清空数据
        map.clear();
        //输出数据
        System.out.println(map);
    }

运行结果：
在这里插入图片描述

2.4 调用containsKey()方法查看是否存在指定的键

public static void main(String[] args) {
        //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
        //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
        Map<Integer,String> map=new HashMap<>();
        //调用put()方法增添数据
        map.put(18,"aaa");
        map.put(19,"bbb");
        map.put(20,"ccc");
        //调用containsKey()方法查看是否存在指定的键
        boolean b = map.containsKey(20);
        System.out.println(b);

        boolean b1 = map.containsKey(21);
        System.out.println(b1);
    }

运行结果：
在这里插入图片描述

2.5 调用containsValue()方法查看是否存在指定的值

public static void main(String[] args) {
        //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
        //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
        Map<Integer,String> map=new HashMap<>();
        //调用put()方法增添数据
        map.put(18,"aaa");
        map.put(19,"bbb");
        map.put(20,"ccc");
        //调用containsValue()方法查看是否存在指定的值
        boolean bbb = map.containsValue("bbb");
        System.out.println(bbb);

        boolean ddd = map.containsValue("ddd");
        System.out.println(ddd);
    }

运行结果：
在这里插入图片描述

2.6 调用isEmpty()方法判断集合是否为空

public static void main(String[] args) {
        //Map为双列存储（一次必须同时存储两个元素）,<key,value>key是键，value是值，键不可以重复，值可以重复
        //创建一个Key数据类型为Integer类型和Value数据类型为String类型的Map对象，由于Map是一个接口，因此在创建对象时必须指定具体实现类（TreeMap和HashMap均可）
        Map<Integer,String> map=new HashMap<>();
        //调用put()方法增添数据
        map.put(18,"aaa");
        map.put(19,"bbb");
        map.put(20,"ccc");
        //调用isEmpty()方法查看集合是否为空
        boolean empty = map.isEmpty();
        System.out.println(empty);
        //调用clear()方法清空数据
        map.clear();
        ////调用isEmpty()方法查看集合是否为空
        boolean empty1=map.isEmpty();
        System.out.println(empty1);
    }

运行结果：
在这里插入图片描述

2.7 调用get()方法根据键获取值

public static void main(String[] args) {
        //创建一个Key的数据类型为String,Value数据类型为Integer的Map对象，并指明其实现类为HashMap
        Map<String ,Integer> map=new HashMap<>();
        //调用put()方法增添数据
        map.put("zhangsan",18);
        map.put("lisi",19);
        map.put("wangwu",20);
        map.put("zhaoliu",21);
        //调用get()方法来获取Key值对应的Value值
        //在Map集合中Key值是非常重要的，我们可以通过Key来获取与Key对应的Value，具体方法为集合调用get()方法
        Integer zhangsan = map.get("zhangsan");
        System.out.println("Key值为zhangsan的Value值："+zhangsan);

        Integer lisi = map.get("lisi");
        System.out.println("Key值为lisi的Value值："+lisi);

        Integer wangwu = map.get("wangwu");
        System.out.println("Key值为wangwu的Value值："+wangwu);

        Integer zhaoliu = map.get("zhaoliu");
        System.out.println("Key值为zhaoliu的Value值："+zhaoliu);
    }

运行结果：
在这里插入图片描述

2.8 调用keySet()方法获取所有键集合

public static void main(String[] args) {
        //创建一个Key的数据类型为String,Value数据类型为Integer的Map对象，并指明其实现类为HashMap
        Map<String ,Integer> map=new HashMap<>();
        //调用put()方法增添数据
        map.put("zhangsan",18);
        map.put("lisi",19);
        map.put("wangwu",20);
        map.put("zhaoliu",21);
        //调用keySet()方法获取所有键的集合，并存入Set集合中
        //由于Key键的数据类型为String，因此Set的数据类型为String
        Set<String> strings = map.keySet();
        for (String string : strings) {
            System.out.println(string);
        }
    }

运行结果：
在这里插入图片描述

三、Map的基本操作代码 Map入门

Key数据类型为String类型，Value数据类型为Integer类型的Map

public static void main(String[] args) {
        //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
        //我们使用泛型来约束Map的数据类型,Key为String数据类型,Value为Integer数据类型
        //其具体实现类为HashMap
        Map<String,Integer> map=new HashMap<>();
        //使用put()方法来添加数据
        map.put("zhangsan",18);
        map.put("lisi",19);
        map.put("wangwu",20);
        map.put("chenliu",21);
        //普通打印
        System.out.println(map);
    }

运行结果：
在这里插入图片描述

接下来我们探讨Key的值不可重复（当Key的值重复的时候，后面插入的对象会将之前插入的具有相同的Key值的对象覆盖掉），Value的值可重复此问题

Key数据类型为Integer类型，Value数据类型为double类型的Map

其中第四对象和第五对象的Value值相同，第三对象与第六对象的Key值相同。

public static void main(String[] args) {
        //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
        //我们使用泛型来约束Map的数据类型,Key为Integer数据类型,Value为Double数据类型
        //其具体实现类为HashMap
        Map<Integer, Double> map=new HashMap<>();
        //使用put()方法来添加数据
        map.put(18,18.99);//第一对象
        map.put(19,20.00);//第二对象
        map.put(20,59.99);//第三对象
        map.put(21,20.11);//第四对象
        map.put(22,20.11);//第五对象
        map.put(20,99.99);//第六对象
        //普通打印
        System.out.println(map);
    }

运行结果：（我们发现后面插入的第六对象将之前插入的第三对象给覆盖掉了，而第四对象与第五对象的Value值重复则不会带来任何影响）
在这里插入图片描述

四、Map的遍历操作 Map基础

Map的遍历分为调用keySet()方法遍历和entrySet()方法遍历

Map调用keySet()方法遍历

public static void main(String[] args) {
        //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
        //我们使用泛型来约束Map的数据类型,Key为Integer数据类型,Value为Double数据类型
        //其具体实现类为HashMap
        Map<Integer, Double> map=new HashMap<>();
        //使用put()方法来添加数据
        map.put(18,18.99);//第一对象
        map.put(19,20.00);//第二对象
        map.put(20,59.99);//第三对象
        map.put(21,20.11);//第四对象
        map.put(22,20.11);//第五对象
        map.put(20,99.99);//第六对象
        
        //调用keySet方法遍历
            //在Map遍历中Key占据着主导地位，可以通过Key值找到对应的Value值
            //调用keySet()方法，Set<>泛型约束应与Key的数据类型一致
            //例如在本代码中，Map<Integer, Double>，Key的数据类型为Integer，因此Set<>泛型约束也应当为Integer
            //Set<Integer> set11=map.keySet();代码的意思为将Map中所有Key值存入Set集合（18，19，20，21，22）
            //那么set11即为Key值集合
            Set<Integer> set11=map.keySet();

            //使用forEach()语句遍历，Integer为set11的数据类型，i为set11的复用名（相当于set11）
            //那么i就成为了Key值
            for(Integer i:set11){
                //在Map遍历中Key占据着主导地位，可以通过Key值找到对应的Value值
                //接下来我们要根据Key值来查找各个Key值对应的Value值
                //Value数据类型为Double，设置一个Double变量来存储Value
                //map.get(i);代码意思为根据i（Key值）找到相对应的Value值
                Double dou=map.get(i);
                
                //打印输出
                System.out.println("Key的值为："+i+"    "+"Value的值为："+dou);
            }
    }

运行结果：（我们发现输出顺序与插入顺序不一致，这是因为我们使用了Set集合来遍历Map，Set集合具有存取数据不一致的问题）
在这里插入图片描述

Map调用entrySet()方法遍历

public static void main(String[] args) {
        //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
        //我们使用泛型来约束Map的数据类型,Key为Integer数据类型,Value为Double数据类型
        //其具体实现类为HashMap
        Map<Integer, Double> map=new HashMap<>();
        //使用put()方法来添加数据
        map.put(18,18.99);//第一对象
        map.put(19,20.00);//第二对象
        map.put(20,59.99);//第三对象
        map.put(21,20.11);//第四对象
        map.put(22,20.11);//第五对象
        map.put(20,99.99);//第六对象
        //调用entrySet方法遍历
            //调用entrySet()方法，Set<>泛型约束应与Map.Entry的数据类型一致，即<Integer, Double>
            //<Key,Value>键值对，在Java语言中又被称之为Entry/entry，Map.Entry就相当于Student.name，若name的数据类型为String，则Student.name的数据类型为String，同理若<key,value>中key的数据类型为Integer，value的数据类型为String，则Map.Entry的数据类型为<Integer,String>，在这里就是<Integer, Double>。
            //Set<Map.Entry<Integer,Double>> set11=map.entrySet();代码的意思为将Map中所有(Key,Value)值存入Set集合[(18,18.99),(19,20.00),(20,99.99),(21,20.11),(22,20.11)]
            //那么set11即为(Key,Value)值集合
            Set<Map.Entry<Integer,Double>> set11=map.entrySet();
            //使用forEach()语句遍历，Integer为set11的数据类型，i为set11的复用名（相当于set11）
            //那么i就成为了(Key,Value)值
            for(Map.Entry<Integer,Double> i:set11){
                //打印输出,直接调用getKey()方法得到Key值,直接调用getValue()得到Value值
                System.out.println("Key的值为："+i.getKey()+"    "+"Value的值为："+i.getValue());
            }
    }

运行结果：（我们发现输出顺序与插入顺序不一致，这是因为我们使用了Set集合来遍历Map，Set集合具有存取数据不一致的问题）
在这里插入图片描述

五、案例Map集合储存学生对象并遍历 Map基础强化

需求：创建一个Map集合，键是学生对象（Student），值是籍贯（String）。
要求：存储三个键值对元素（Entry），并遍历

Student类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Map遍历输出

public static void main(String[] args) {
        //若要使用Map，我们需要导入import java.util.HashMap;与import java.util.Map;
        //我们使用泛型来约束Map的数据类型,Key为Student数据类型,Value为String数据类型
        //其具体实现类为HashMap
        Map<Student, String> map=new HashMap<>();
        //创建Student对象元素
        Student student1=new Student("zhangsan",18);
        Student student2=new Student("lisi",29);
        Student student3=new Student("wangwu",33);
        //使用put()方法来添加数据
        map.put(student1,"北京");
        map.put(student2,"上海");
        map.put(student3,"广州");
        //调用keySet方法遍历
        //在Map遍历中Key占据着主导地位，可以通过Key值找到对应的Value值
        //调用keySet()方法，Set<>泛型约束应与Key的数据类型一致
        //例如在本代码中，Map<Student, String>，Key的数据类型为Student，因此Set<>泛型约束也应当为Student
        //Set<Student> set11=map.keySet();代码的意思为将Map中所有Key值存入Set集合（student1，student2，student3）
        //那么set11即为Key值集合
        Set<Student> set11=map.keySet();

        //使用forEach()语句遍历，Student为set11的数据类型，i为set11的复用名（相当于set11）
        //那么i就成为了Key值
        for(Student i:set11){
            //在Map遍历中Key占据着主导地位，可以通过Key值找到对应的Value值
            //接下来我们要根据Key值来查找各个Key值对应的Value值
            //Value数据类型为String，设置一个String变量来存储Value
            //map.get(i);代码意思为根据i（Key值）找到相对应的Value值
            String str=map.get(i);

            //打印输出
            System.out.println("Key的值为："+i+"    "+"Value的值为："+str);
        }

        System.out.println("====华丽的分割线====");

        //调用entrySet方法遍历
        //调用entrySet()方法，Set<>泛型约束应与Map.Entry的数据类型一致，即<Student, String>
        //<Key,Value>键值对，在Java语言中又被称之为Entry/entry，Map.Entry就相当于Student.name，若name的数据类型为String，则Student.name的数据类型为String，同理若<key,value>中key的数据类型为Integer，value的数据类型为String，则Map.Entry的数据类型为<Integer,String>，在这里就是<Student, String>。
        //Set<Map.Entry<Student, String>> set22=map.entrySet();代码的意思为将Map中所有(Key,Value)值存入Set集合[(Student("zhangsan",18),"北京"),(Student("lisi",29),“上海”),(Student("wangwu",33),“广州”)]
        //那么set22即为(Key,Value)值集合
        Set<Map.Entry<Student, String>> set22=map.entrySet();
        //使用forEach()语句遍历，Integer为set11的数据类型，i为set22的复用名（相当于set22）
        //那么i就成为了(Key,Value)值
        for(Map.Entry<Student, String> i:set22){
            //打印输出,直接调用getKey()方法得到Key值,直接调用getValue()得到Value值
            System.out.println("Key的值为："+i.getKey()+"    "+"Value的值为："+i.getValue());
        }
    }

运行结果：（我们发现输出顺序与插入顺序不一致，这是因为我们使用了Set集合来遍历Map，Set集合具有存取数据不一致的问题）
在这里插入图片描述

OK！！！Map介绍结束！！！

【Java基础知识 1】Java入门级概述
学Java，找哪吒
09-25 16万+
CSDN最强Java专栏，包含全部Java基础知识点、Java8新特性、Java集合、Java多线程、Java代码实例，理论结合实战，实现Java的轻松学习。
Java中的Map
qq_41571224的博客
01-03 9324
Map5.1Map集合的概述和使用5.1.15.2Map集合的基本功能5.3 Map集合的获取功能5.4Map集合的遍历(方式1：将键获取到一个集合，再将键的集合遍历获取对应的值)5.5 Map集合的遍历(方式2） 5.1Map集合的概述和使用 Interface Map<K,V> K:Map集合中key的类型 V:Map集合中value的类型 All Known Implementing Classes: AbstractMap, Attributes, AuthProvider, Concu
Java中Map的深入解析与实战应用
星途码客的博客
09-28 2218
Map是Java中的一个接口，位于java.util包下。它定义了一组用于操作键值对的方法，包括插入、删除、查找和遍历等操作。Map中的每个元素都是一个键值对（Key-Value Pair），键是唯一的，而值则可以是任意的对象。Map是Java中非常强大且灵活的数据结构，它通过键值对的方式提供了高效的数据存取机制。通过深入理解Map接口及其实现类，掌握其基本操作和高级特性，我们可以更加灵活地将其应用于各种开发场景中。希望本文能帮助读者更好地理解和使用Java中的Map。
在Java中map的使用与说明
qq_43158726的博客
06-26 1252
Java 中的 Map 接口有多个实现类，如 HashMap、TreeMap 和 LinkedHashMap，每个实现都有其特定的性能特点和用途。Map 接口和其实现类是 Java 集合框架中非常重要的部分，适用于不同的应用场景和需求。熟练掌握 Map 的使用技巧，可以大大提高代码的效率和灵活性。在实际开发中，根据具体的需求选择合适的 Map 实现，可以有效地解决各种复杂的数据存储和处理问题。Map 是一个接口，定义了一组用于操作键值对的方法，包括插入、删除、查找和遍历等操作。常用的 Map 实现。
java基础——java集合map详解
最新发布
likuoelie的博客
09-14 1382
Java Map 是一个存储键值对的接口，具有键唯一、值可重复的特性。主要实现类包括： HashMap：基于哈希表，无序高效，允许null键值 LinkedHashMap：保持插入顺序 TreeMap：基于红黑树，按键排序 Hashtable：线程安全但性能较低 ConcurrentHashMap：高并发优化的线程安全实现 Map提供put/get/remove等核心方法，支持快速查找(O(1)或O(log n))。不同实现类适用于不同场景，如HashMap适合缓存，TreeMap适合有序数据，Concur
Java基础 集合（四）Map详解
A乐神的博客
02-01 1308
Java基础 集合（四）Map详解
Java中Map详解
Zhujiang
03-05 3万+
用法 Map:java.util 中的集合类包含 Java 中某些最常用的类。最常用的集合类是 List 和 Map。 Map 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对（称作“键”和“值”），其中每个键映射到一个值。 本文主要介绍java map的初始化、用法、map的两种常用的遍历方式。 map存放值的时候通过put存放，如果key值相等的话会把之前存放的值覆盖。 ...
Java中Map的使用
weixin_30247781的博客
08-19 137
Map以按键/数值对的形式存储数据，和数组很类似，在数组中存在的索引，它们本身也是对象。 Map的接口 Map－－－实现Map Map.Entry－－Map的内部类，描写叙述Map中的按键/数值对。 SortedMap---扩展Map，使按键保持升序排列 关于怎么使用，通常是选择Map的子类，而不直接用Map类。 ...
Java基础教程之Map集合深入讲解及其应用
11-28
适用人群：适合具有一定Java基础知识的学习者，尤其是想深入了解Java集合框架的开发者和技术人员。 使用场景及目标：① 学习者希望通过此文全面掌握Map接口及其主要实现类的功能与应用场景；② 开发人员希望在实际...
Java基础知识-day04 【Map】.pdf
10-26
Java基础知识-day04 【Map】.pdf 本文档主要讲解Java中的Map集合，包括Map集合的概述、Map常用子类、Map接口中的常用方法、Map集合遍历键找值方式等。 Map集合概述 Map集合是一种特殊的集合，用于存储键值对对象...
Java基础知识总结（超详细整理）
02-02
【Java基础知识总结】 Java是一种广泛使用的高级编程语言，由Sun Microsystems公司（现为Oracle Corporation的一部分）于1995年发布。它以其“一次编写，到处运行”的特性而闻名，这意味着编写好的Java代码可以在...
Java基础知识笔试题及答案
11-23
Java 基础知识笔试题及答案 Java 是一种广泛使用的编程语言，它具有强大的功能和灵活性。本资源汇总了 Java 基础知识笔试题及答案，涵盖了 Java 的基本概念、数据类型、运算符、控制结构、函数、数组、集合框架、...
Java Map 集合类简介
热门推荐
幽客独往
11-03 10万+
java.util 中的集合类包含 Java 中某些最常用的类。 最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。 Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作“键”和“值”），其中每个键
java 之 map
aningxiaoxixi的博客
06-11 728
在 Java 中，是一种用于存储的集合接口，属于java.util包。它通过键（Key）快速查找对应的值（Value），键必须唯一，值可以重复。
Java中的Map（如果想知道Java中有关Map的知识点，那么只看这一篇就足够了！）
秋刀鱼不做梦的编程日常
08-04 1万+
Java中的Map（如果想知道Java中有关Map的知识点，那么只看这一篇就足够了！）
JAVA中的Map
weixin_42352733的博客
11-03 3万+
接口概述 我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同， Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。 Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。 Collection中的集合称为单列集合，Map中的集合称为双列集合。 需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。，
Java集合--Map
qq_33807380的博客
12-14 2844
在Java的集合框架中，Map为双列集合，在Map中的元素是成对以键值对的形式存在的，通过键可以找对所对应的值。Map接口有许多的实现类，各自都具有不同的性能和用途。常用的Map接口实现类有HashMapHashtableTreeMap和。HashMap 是 Java 中一个非常常用的集合类，可以通过key的 HashCode 值来快速访问值，具有很快的访问速度，并且由于存储的键值对是无序的，插入的顺序并不会影响到查询的结果。
java基础知识map集合
03-30
<think>好的，我现在需要帮助用户解答关于Java基础知识中的Map集合的问题。首先，我要回顾用户之前的对话历史，了解他们之前遇到了什么问题。之前的对话中，用户询问了一段使用HashMap的代码为什么无法正常输出企鹅信息，我指出是因为没有重写toString方法，并给出了改进建议。现在用户的新问题是关于Java Map集合的基础知识，他们可能想系统地了解Map的相关内容。 首先，我需要确认用户的需求是什么。他们可能刚开始学习Java，对集合框架中的Map不太熟悉，需要基础知识的讲解。或者他们在实际编程中遇到了Map相关的问题，需要进一步理解其特性和使用方法。根据用户的问题“java基础知识map集合”，可以推断他们希望获得一个概述性的介绍，包括Map的基本概念、常用实现类、核心方法、遍历方式以及使用注意事项。 接下来，我需要组织回答的结构。通常，基础知识介绍需要清晰的分点，涵盖定义、特点、常用实现类、核心方法、遍历方式、使用场景、注意事项等。同时，用户之前的代码示例中使用了HashMap和Iterator遍历，因此在讲解遍历方式时，可以提到不同的方法，包括Iterator和增强型for循环，这有助于用户将新旧知识联系起来。 在回答中需要注意用户可能的盲点。例如，用户之前的问题涉及到toString方法的重写，可能在自定义对象作为Value时需要注意正确实现equals和hashCode方法，这也是Map使用中的一个重要点，需要提及。此外，线程安全的问题，比如HashMap非线程安全，而Hashtable是线程安全的，但ConcurrentHashMap更高效，这些高级内容虽然基础，但可以简要提到，帮助用户建立全面的认识。 同时，用户可能对Map的各个实现类的区别不太清楚，比如HashMap、LinkedHashMap、TreeMap之间的不同，需要明确它们的特点和适用场景。例如，HashMap无序，LinkedHashMap保持插入顺序，TreeMap可排序，这些都需要用简洁的例子或对比表格来说明。 还要注意使用用户之前接触过的代码示例中的元素，比如HashMap的entrySet方法遍历，这样用户更容易理解。在讲解遍历方式时，可以提到用户之前使用的Iterator方式，并推荐更简洁的增强型for循环，这样既巩固旧知识，又引入新建议。 另外，用户可能对泛型的使用有疑问，之前的代码中已经正确使用了泛型，因此在注意事项中可以强调类型安全的重要性，并建议始终使用泛型，避免原始类型，这有助于预防类型转换错误。 最后，总结部分需要简明扼要地回顾Map的核心知识点，并鼓励用户进行实践。考虑到用户之前的问题可能是在实际编码中遇到的，强调实践的重要性可以帮助他们更好地掌握这些概念。 在编写过程中，要确保语言通俗易懂，避免过于专业的术语，但必要的术语仍需准确使用。同时，检查是否有遗漏的重要知识点，如Map的键唯一性、值可重复、允许空键空值（根据实现类不同）等，这些都需要涵盖在内。 总结下来，回答的结构应该是： 1. Map的定义与特点 2. 常用实现类对比 3. 核心方法 4. 遍历方式 5. 使用场景 6. 注意事项 7. 总结 每个部分需要简明扼要，举例说明，并尽量联系用户之前的代码示例，帮助他们更好地理解。同时，注意代码示例的正确格式，使用中文注释，帮助用户理解每段代码的作用。</think>以下是Java中Map集合的核心知识体系梳理： 一、Map的定义与特点 1. 双列集合结构：存储键值对(key-value)数据，数学表示为$K \rightarrow V$的映射关系 2. 三大核心特性： - 键唯一性：每个key对应唯一value（类似函数定义域） - 值可重复：不同key可以对应相同value - 键值对存取：通过key快速定位value（时间复杂度接近$O(1)$） 二、常用实现类对比 | 类名 | 数据结构 | 顺序特性 | 线程安全 | 允许null键值 | 时间复杂度 | |-----------------|-----------|-----------------|--------|------------|----------| | HashMap | 数组+链表/红黑树 | 无序 | 不安全 | 允许 | O(1) | | LinkedHashMap | 链表+哈希表 | 保持插入/访问顺序 | 不安全 | 允许 | O(1) | | TreeMap | 红黑树 | 按键自然排序 | 不安全 | 不允许 | O(log n) | | Hashtable | 数组+链表 | 无序 | 安全 | 不允许 | O(1) | | ConcurrentHashMap| 分段锁机制 | 无序 | 安全 | 不允许 | O(1) | 三、核心方法详解 ```java // 基础操作 V put(K key, V value); // 添加/替换键值对 V get(Object key); // 根据key获取value boolean containsKey(Object key);// 检查key是否存在 V remove(Object key); // 删除指定key的映射 // 集合视图 Set<K> keySet(); // 获取所有key的集合 Collection<V> values(); // 获取所有value的集合 Set<Map.Entry<K,V>> entrySet(); // 获取所有键值对集合 // 特殊操作 default V getOrDefault(Object key, V defaultValue); // 安全获取值 void forEach(BiConsumer<? super K,? super V> action); // Java8遍历 ``` 四、遍历方式对比（以HashMap为例） 1. EntrySet迭代器遍历（用户示例中的方式） ```java Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator(); while(it.hasNext()) { Map.Entry<Integer, String> entry = it.next(); System.out.println(entry.getKey() + ":" + entry.getValue()); } ``` 2. 增强for循环遍历（推荐方式） ```java for(Map.Entry<Integer, String> entry : map.entrySet()) { System.out.println(entry.getKey() + "->" + entry.getValue()); } ``` 3. Lambda表达式遍历（Java8+） ```java map.forEach((k, v) -> System.out.println(k + "=" + v)); ``` 五、典型使用场景 1. 数据缓存：使用HashMap实现快速查询 2. 配置存储：Properties类继承Hashtable 3. 数据统计：用TreeMap实现有序统计 4. 并发场景：ConcurrentHashMap处理高并发访问 六、注意事项 1. 键对象必须正确重写`hashCode()`和`equals()`方法 2. 初始容量与负载因子设置（默认0.75，空间与时间的权衡） 3. 并发修改异常：遍历时修改集合可能抛出ConcurrentModificationException 4. 使用泛型保证类型安全（如`Map<String, Integer>`） 七、底层原理简析（以HashMap为例） 1. 哈希桶结构：数组的每个元素称为桶（bucket） 2. 哈希冲突处理： - 链表法：JDK1.8前使用纯链表 - 红黑树：当链表长度>8时转换（提升查询效率） 3. 扩容机制：当size > capacity*loadFactor时，扩容为原来2倍 建议通过调试工具观察HashMap的结构变化，结合《Effective Java》中关于equals/hashCode的实现规范，可以深入理解Map集合的设计哲学。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值