Java中Map集合概述、API、遍历方式

 

 

Map集合实现类的特点：

• HashMap：元素按照键是无序、不重复、无索引，值不做要求（与Map体系一致）；

 示例运行结果：

•  LinkedHashMap：元素按照键是有序、不重复、无索引，值不做要求

由于上边的HashMap集合是采用多态的方式写的，因此此处我们仅需修改一处代码即可实现LinkedHashMap样例：

 

 示例运行结果：

 

 Map集合的概述以及常用的API：

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

public class MapDemo {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
        maps.put("Java",3);
        maps.put("C#",2);
        maps.put("HTML",1);
        maps.put("MySQL",3);
        maps.put("JavaScript",5);
        System.out.println(maps);
        //清空集合
//        maps.clear();
//        System.out.println(maps);
        //判断集合是否为空
        System.out.println(maps.isEmpty());
        //根据键获取对应值
        System.out.println(maps.get("Java"));
        //根据键删除整个元素
        maps.remove("C#");
        System.out.println(maps);
        //判断是否包含某个键
        System.out.println(maps.containsKey("html"));
        System.out.println(maps.containsKey("HTML"));
        //判断是否包含某个值
        System.out.println(maps.containsValue(6));
        System.out.println(maps.containsValue(3));
        //获取所有的键
        Set<String> keys = maps.keySet();
        System.out.println(keys);
        //获取所有的值
        Collection<Integer> values = maps.values();
        System.out.println(values);
        //集合的大小
        System.out.println(maps.size());
        //合并其它的Map集合
        Map<String,Integer> map1 = new HashMap<>();
        map1.put("k1_map1",1);
        map1.put("k1_map2",3);
        map1.put("k1_map3",2);
        Map<String,Integer> map2 = new HashMap<>();
        map2.put("Java",5);
        map2.putAll(map1);
        System.out.println(map2); //把map1的元素拷贝一份放置到map2中
        System.out.println(map1);
    }
}

示例运行结果：

 

 Map集合遍历

• 方式1：键找值

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

public class MapDemo1 {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
        maps.put("Java",3);
        maps.put("C#",2);
        maps.put("HTML",1);
        maps.put("MySQL",3);
        maps.put("JavaScript",5);
        //键找值，1、获取集合中所有的键
        Set<String> keys = maps.keySet();
        //2、遍历每个键，根据键提取对应的值
        for (String key : keys) {
            System.out.println(key + "--->" + maps.get(key));
        }
    }
}

示例运行结果：

 

•  方式2：键值对

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

public class MapDemo2 {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
        maps.put("Java",3);
        maps.put("C#",2);
        maps.put("HTML",1);
        maps.put("MySQL",3);
        maps.put("JavaScript",5);
        Set<Map.Entry<String, Integer>> entries = maps.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key + "--->" + value);
        }
    }
}

示例运行结果：

 

•  方式3：Lambda表达式

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class MapDemo3 {
    public static void main(String[] args) {
        Map<String,Integer> maps = new HashMap<>();
        maps.put("Java",3);
        maps.put("C#",2);
        maps.put("HTML",1);
        maps.put("MySQL",3);
        maps.put("JavaScript",5);
//        maps.forEach(new BiConsumer<String, Integer>() {
//            @Override
//            public void accept(String key, Integer value) {
//                System.out.println(key + "--->" + value);
//            }
//        });
        maps.forEach((s, integer) -> System.out.println(s + "->" + integer));
    }
}

•  Map集合案例--统计投票人数
• 需求：某个班级有80名学生，现在需要组成秋游活动，班长提供了四个景点依次是A、B、C、D，每个学生只能选择一个景点，请统计出最终那个景点想去的人最多。

分析：

1. 将80个学生的选择数据拿到程序中去。
2. 定义一个Map集合用于存储最终统计的结果。
3. 遍历80个学生选择的数据，看Map集合中是否存在，不存在存入“数据=1”

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

public class MapTest {
    public static void main(String[] args) {
        //定义一个数组用于存储生成的四种选择
        String[] selects = {"A","B","C","D"};
        //随机数生成一组80个字符的字符串
        Random random = new Random();
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 80; i++) {
            sb.append(selects[random.nextInt(4)]);
        }
        System.out.println(sb);
        //定义一个Map集合{选项=人数}
        Map<Character,Integer> maps = new HashMap<>();
//遍历方法一        
        //遍历80个学生的选择<方法一>
        for (int i = 0; i < sb.length(); i++) {
            char ch = sb.charAt(i);
            //说明改选择不是第一次出现
            if(maps.containsKey(ch)){
                maps.put(ch,maps.get(ch) + 1);
            }else {
                //第一次出现改选择
                maps.put(ch,1);
            }
        }
        System.out.println(maps);
        //遍历方法二（更加优化），先初始化maps集合，后边计算时可根据键直接增加选项的次数
//        maps.put('A',0);
//        maps.put('B',0);
//        maps.put('C',0);
//        maps.put('D',0);
        
        //遍历80个学生的选择
//        for (int i = 0; i < sb.length(); i++) {
//            char ch = sb.charAt(i);
//            maps.put(ch,maps.get(ch)+1);
//        }
//        System.out.println(maps);
    }
}

示例运行结果：

 

 

•  HashMap底层原理：实际上，Set系列集合的底层就是Map实现的，只是Set集合中的元素只要键数据，不要值数据而已：
• 由键决定：无序、不重复、无索引。HashMap底层是哈希表结构；
• 依赖hashCode方法和equals方法保证键的唯一性；
• 如果键要存储的是自定义的对象，需要重写hashCode和equals方法；
• 基于哈希表，增删查改性能都较好

 

 

 

import com.companyName.d1_set.Student;

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

public class HashMapDemo {
    public static void main(String[] args) {
        Map<Student,String> stus = new HashMap<>();
        Student s1 = new Student("Jack",21,'男');
        Student s2 = new Student("Jack",21,'男');
        Student s3 = new Student("Rose",20,'女');

        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println(s3.hashCode());
 
        stus.put(s1,"美国");
        stus.put(s2,"加拿大");
        stus.put(s3,"古巴");

        System.out.println(stus);
    }
}

示例运行结果：

 

 

•  LinkedHashMap集合底层数据结构：

 

 

 TreeSet & TreeMap:

 

 从源码中可以看到：TreeSet集合底层就是用TreeMap集合实现的

TreeMap集合排序方法：

• 方式一
• 类自定义比较规则：

 

•  方式二
• 集合自带比较器：

 示例运行结果：

 

 

•  补充知识：集合的嵌套
• 案例：Map集合案例--统计投票人数
• 需求：某个班级有多名学生，现在需要组成秋游活动，班长提供了4个景点依次是A、B、C、D，每个学生可以选择多个景点，请统计出最终那个景点想去的人最多。

分析：

1. 将学生选择的数据拿到程序中去，需要记住每个学生选择的情况；
2. 定义Map集合用于存储最终统计的结果。

❌错误方法演示：

import java.util.*;

public class MapTest {
    public static void main(String[] args) {
        Map<String, Set<String>> maps = new HashMap<>();

        //Set集合保存每个学生的选项
        Set<String> sets1 = new HashSet<>();
        Collections.addAll(sets1,"A","B","D");
        maps.put("高锋",sets1);

        Set<String> sets2 = new HashSet<>();
        Collections.addAll(sets2,"B","D");
        maps.put("韩寒",sets2);

        Set<String> sets3 = new HashSet<>();
        Collections.addAll(sets3,"A","C","D");
        maps.put("赵冰",sets3);
        System.out.println(maps);

        //遍历集合统计元素
        Map<String,Integer> ret = new HashMap<>();
        ret.put("A",0);
        ret.put("B",0);
        ret.put("C",0);
        ret.put("D",0);
        //取出maps集合中嵌套的所有值，即内部的Set集合中的所有元素
        
        List<String> values = maps.values();
    }
}

本来想着用Set集合保存每个学生选择的景点以防止有一个景点被重选的，但是发现在第29行取出所有集合中元素的时候只能用Set类型的集合接收，而Set集合又是去重复的，这样做显然不合适，所以用

List集合更合适（从前端选择进行控制不能一个选项多选），可以保留重复的选项。

 

✔示例：

import java.util.*;

public class MapTest {
    public static void main(String[] args) {
        Map<String, List<String>> maps = new HashMap<>();

        //Set集合保存每个学生的选项
        List<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"A","B","D");
        maps.put("高锋",list1);

        List<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"B","D");
        maps.put("韩寒",list2);

        List<String> list3 = new ArrayList<>();
        Collections.addAll(list3,"A","C","D");
        maps.put("赵冰",list3);
        System.out.println(maps);

        //遍历集合统计元素
        Map<String,Integer> ret = new HashMap<>();
        ret.put("A",0);
        ret.put("B",0);
        ret.put("C",0);
        ret.put("D",0);
        //取出maps集合中嵌套的所有值，即内部的Set集合中的所有元素
        Collection<List<String>> values = maps.values();
        for (List<String> value : values) {  // [A, B, D], [A, C, D], [B, D]
            for (String s : value) { //逐个遍历集合中每个元素
                ret.put(s,ret.get(s)+1);
            }
        }
        System.out.println(ret);
    }
}

示例运行结果：