Java的编程之旅49——Map集合

惊爆点大男主

于 2024-07-15 14:37:10 发布

阅读量888

点赞数 28

分类专栏： Java的编程之旅文章标签： java 开发语言 Map集合的常用方法 Map集合的遍历 Map与List之间的互相存储统计字符个数

本文链接：https://blog.csdn.net/weixin_62621407/article/details/140413966

版权

Java的编程之旅专栏收录该内容

49 篇文章 0 订阅

订阅专栏

在Java中，Map是一个接口，用于存储键值对的集合。它提供了一系列的方法来操作和访问这些键值对。Java中常见的Map实现类有HashMap、TreeMap、LinkedHashMap等。Map集合在Java中广泛应用于各种场景，如缓存、数据存储、数据处理等。它提供了快速查找和访问的能力，并且可以轻松地存储和处理大量的键值对数据。

1.HashMap：是最常用的Map实现类，它使用哈希表来存储键值对。HashMap不保证元素的顺序，它允许使用null作为键和值，并且具有较快的访问速度。

2.TreeMap：是一个有序的Map实现类，它基于红黑树的数据结构来存储键值对。TreeMap会按照键的自然顺序（或者通过Comparator进行排序）来对键进行排序，并且不允许使用null作为键。

3.LinkedHashMap：是一个有序的Map实现类，它基于哈希表和双向链表来存储键值对。LinkedHashMap保留了插入顺序，即可以按照插入的顺序进行遍历，同时也支持按照访问顺序进行遍历。

1语法格式：

Map<K,V> map = new HashMap<>();

这里的K为键可以为任意的数据类型，V为值同样也可以为任意的数据类型

        Map<String, String> map = new HashMap<>();
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        map.put("4","d");
        System.out.println(map);
        map.put("2","B");  //map中使用put函数时，key存在表示添加成员，不存在表示修改成员
        System.out.println(map);

这段代码创建了一个Map集合对象，并使用HashMap作为实现类。初始时，集合中包含四对键值对，分别是(1, "a")、(2, "b")、(3, "c")和(4, "d")。

然后使用put方法向集合中添加一对键值对，键为"2"，值为"B"，由于之前已经存在键为"2"的键值对，所以会将值从"b"修改为"B"。

最后通过System.out.println方法打印出了修改后的Map集合，输出结果为{1=a, 2=B, 3=c, 4=d}。可以看到，键为"2"的值已经被修改为"B"。

注意：map中使用put函数时，key存在表示添加成员，不存在表示修改成员

2.Map集合的常用方法

Map接口定义了一系列的方法，包括插入、删除、查找等操作。常用的方法有：

put(key, value)：向Map中插入键值对。
remove(key)：根据键删除对应的键值对。
isEmpty():判断集合是否为空。
size():返回集合元素个数。
containsKey(key)：判断Map中是否包含指定的键。
containsValue(Value)：判断Map中是否包含指定的值。
clear():清空集合
get(key)：根据键获取对应的值。
keySet()：返回Map中所有键的集合。
values()：返回Map中所有值的集合。
entrySet()：返回Map中所有键值对的集合。

        HashMap<String, String> map = new HashMap<>();
        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        map.put("4","d");
        System.out.println(map.remove("2"));//通过键删除值，返回被删除的值
        System.out.println(map.isEmpty());     //判断集合是否为空
        //map.clear();//清空集合
        System.out.println(map.size());//返回集合元素个数
        System.out.println(map.containsKey("4"));//判断键是否存在
        System.out.println(map.containsValue("c"));//判断值是否存在
        System.out.println(map);

3.Map集合的遍历

        HashMap<String, String> map = new HashMap<>();

        map.put("1","a");
        map.put("2","b");
        map.put("3","c");
        map.put("4","d");
        //法一：直接遍历获取值
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }

        //法二：通过遍历键获取值
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key+"<==>"+map.get(key));
        }

        //法三：获取所有键值对的集合，然后分别获取键和值
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key+"<==>"+value);
        }

该代码演示了三种不同的遍历HashMap的方法：

方法一：直接遍历获取值使用map.values()方法可以获取HashMap中所有的值，然后通过for-each循环遍历打印出每个值。

方法二：通过遍历键获取值使用map.keySet()方法可以获取HashMap中所有的键，然后通过for-each循环遍历每个键，并通过map.get(key)方法获取对应的值，打印出键和值的对应关系。

方法三：获取所有键值对的集合，然后分别获取键和值使用map.entrySet()方法获取HashMap中所有的键值对，得到一个Set集合，集合中的每个元素都是一个Entry对象，包含键和值。通过for-each循环遍历每个Entry对象，使用entry.getKey()获取键，entry.getValue()获取值，打印出键和值的对应关系。

这三种方法都可以用来遍历HashMap，具体选择哪种方法取决于具体的需求。

例：获取学生信息

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 +
                '}';
    }
}

public class StuTest {
    public static void main(String[] args) {
        HashMap<Integer, Student> map = new HashMap<>();
        map.put(1,new Student("A",15));
        map.put(2,new Student("B",16));
        map.put(3,new Student("C",17));
        map.put(4,new Student("D",18));


        //通过map.values()方法获取学生姓名和年龄
        Collection<Student> values = map.values();
        for (Student value : values) {
            System.out.println("姓名:"+value.getName()+"  年龄："+value.getAge());
        }

        //通过map.keySet()方法获取学生的学号，姓名和年龄（即获取集合中的键和值)
        Set<Integer> keys = map.keySet();
        for (Integer key : keys) {
            System.out.println("学号:"+key+"  姓名:"+map.get(key).getName()+"  年龄："+map.get(key).getAge());
        }

        //通过map.entrySet()方法
        Set<Map.Entry<Integer, Student>> entries = map.entrySet();
        for (Map.Entry<Integer, Student> entry : entries) {
            Integer key = entry.getKey();
            Student value = entry.getValue();
            System.out.println("学号:"+key+"  姓名:"+value.getName()+"  年龄："+value.getAge());
        }

    }
}

该代码演示了如何遍历一个HashMap，其中HashMap的键是学生的学号，值是学生对象。每个学生对象有姓名和年龄两个属性。

首先，创建一个HashMap对象，键的类型是Integer，值的类型是Student。

然后，使用put方法将学号和对应的学生对象放入HashMap中。

接下来，通过三种不同的方法遍历HashMap。

方法一：通过map.values()方法获取学生姓名和年龄使用map.values()方法可以获取HashMap中所有的学生对象，然后通过for-each循环遍历每个学生对象，使用getName()和getAge()方法获取学生的姓名和年龄，打印出来。

方法二：通过map.keySet()方法获取学生的学号，姓名和年龄（即获取集合中的键和值）使用map.keySet()方法可以获取HashMap中所有的学生学号，然后通过for-each循环遍历每个学号，并通过map.get(key)方法获取对应的学生对象，使用getName()和getAge()方法获取学生的姓名和年龄，打印出来。

方法三：通过map.entrySet()方法获取学生的学号，姓名和年龄使用map.entrySet()方法获取HashMap中所有的键值对，得到一个Set集合，集合中的每个元素都是一个Entry对象，包含学号和对应的学生对象。通过for-each循环遍历每个Entry对象，使用entry.getKey()获取学号，entry.getValue()获取学生对象，使用getName()和getAge()方法获取学生的姓名和年龄，打印出来。

这三种方法都可以用来遍历HashMap，具体选择哪种方法取决于具体的需求和数据结构。

运行结果：

4.Map集合中存储List集合

/**
 * map集合中存储list集合
 */

public class Test {
    public static void main(String[] args) {
        HashMap<String, ArrayList<String>> map = new HashMap<>();   //先new HashMap 再new ArrayList
        ArrayList<String> list01 = new ArrayList<>();
        ArrayList<String> list02 = new ArrayList<>();
        ArrayList<String> list03 = new ArrayList<>();

        //list中添加元素
        list01.add("A");
        list01.add("B");
        list01.add("C");
        list01.add("D");

        list02.add("a");
        list02.add("b");
        list02.add("c");
        list02.add("d");

        list03.add("1");
        list03.add("2");
        list03.add("3");
        list03.add("4");

        //将list集合放入map中
        map.put("1",list01);
        map.put("2",list02);
        map.put("3",list03);

        //遍历map集合，再在循环中遍历list
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key);
            ArrayList<String> list = map.get(key);
            for (String li : list) {
                System.out.println("\t"+li);
            }
        }

        Collection<ArrayList<String>> values = map.values();
        for (ArrayList<String> value : values) {
            System.out.println(value);
        }

        Set<Map.Entry<String, ArrayList<String>>> entries = map.entrySet();
        for (Map.Entry<String, ArrayList<String>> entry : entries) {
            String key = entry.getKey();
            ArrayList<String> value = entry.getValue();
            System.out.println(key);
            for (String s : value) {
                System.out.println("\t"+s);
            }
        }
    }
}

以上代码演示了如何在Map集合中存储List集合。首先，创建了一个HashMap对象来存储List集合，键的类型是String，值的类型是ArrayList<String>。

然后，创建了三个ArrayList对象来存储不同的元素。每个ArrayList对象都添加了一些字符串元素。

接下来，将这三个ArrayList对象分别放入HashMap中，使用不同的键进行关联。

然后，通过遍历HashMap的键集合来访问HashMap中的数据。在循环中，通过get方法获取键对应的ArrayList对象，然后再次进行遍历来访问ArrayList中的元素。

同样的，通过遍历HashMap的值集合和Entry集合也可以实现对Map中的List集合进行访问。

最后，打印出了Map中存储的List集合的元素。

5.List集合中存储Map集合

/**
 * list集合存储HashMap集合
 */
public class Test {
    public static void main(String[] args) {


        ArrayList<HashMap<String, String>> list = new ArrayList<>();
        HashMap<String, String> map01 = new HashMap<>();
        HashMap<String, String> map02 = new HashMap<>();
        HashMap<String, String> map03 = new HashMap<>();

        map01.put("A","a");
        map01.put("B","b");

        map02.put("C","c");
        map02.put("D","d");

        map03.put("E","e");
        map03.put("F","f");

        list.add(map01);
        list.add(map02);
        list.add(map03);

        //法一
        for (HashMap<String, String> map : list) {
            Set<String> keys = map.keySet();
            for (String key : keys) {
                System.out.println(key+"<==>"+map.get(key));
            }
        }

        //法二
        for (HashMap<String, String> map : list) {
            Set<Map.Entry<String, String>> entries = map.entrySet();
            for (Map.Entry<String, String> entry : entries) {
                String key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key+"<==>"+value);
            }
        }
    }
}

以上代码演示了如何在List集合中存储HashMap集合。首先，创建了一个ArrayList对象来存储HashMap集合，泛型类型为HashMap<String, String>。

然后，创建了三个HashMap对象来存储键值对。每个HashMap对象都添加了一些键值对。

接下来，将这三个HashMap对象分别放入ArrayList中。

然后，通过遍历ArrayList，可以访问其中的HashMap对象。在循环中，通过get方法获取键对应的值，然后打印键值对。

另外一种方式是通过遍历HashMap的Entry集合。在循环中，通过getKey方法获取键，通过getValue方法获取值，然后打印键值对。

最后，打印出了List中存储的HashMap集合的键值对。

运行以上代码，输出结果如下：

A<==>a
B<==>b
C<==>c
D<==>d
E<==>e
F<==>f

6.统计字符个数

import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

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

        System.out.println("输入一段文字");
        String str = new Scanner(System.in).nextLine();

        TreeMap<Character, Integer> map = new TreeMap<>();
        for (int i = 0; i < str.length(); i++) {             //遍历字符串长度
            char key = str.charAt(i);                        //获取每个字符（键）
            Integer count = map.get(key);                    //获取字符个数（值）
            if(null==count){
                map.put(key,1);
            }else {
                map.put(key,++count);
            }
        }

        Set<Character> keySet = map.keySet();
        for (Character key : keySet) {
            System.out.println(key+ "：出现了"+map.get(key)+"个");
        }
    }
}

首先，程序使用Scanner类来获取用户输入的一段文字。然后，程序创建一个TreeMap对象来存储字符和对应的出现次数。

接下来，程序通过一个循环遍历输入文字的每个字符。在循环中，程序首先获取当前字符（键），然后通过get()方法来获取该字符在TreeMap中的出现次数（值）。如果出现次数为null，说明该字符还未出现过，程序将该字符作为键，出现次数设置为1，并将键值对存入TreeMap。否则，程序将该字符的出现次数加1，并更新键值对。

最后，程序遍历TreeMap中的每个键，输出每个键和对应的出现次数。

这段代码使用TreeMap来存储字符和对应的出现次数，这样可以保证键按照字母顺序进行排序。输出时会按照字母顺序输出每个字符和对应的出现次数。