Map集合（HashMap集合、LinkedHashMap集合、TreeMap集合）

Map集合

双列集合，就是说集合中的元素是一对一对的。Map集合中的每一个元素是以key=value的形式存在的，一个key=value就称之为一个键值对，而且在Java中有一个类叫Entry类，Entry的对象用来表示键值对对象。

特点：键不能重复，值可以重复，每一个键只能找到自己对应的值。

Map集合体系的特点:

注意: Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的

1. HashMap (由键决定特点): 无序、不重复、无索引; (用的最多)
2. LinkedHashMap (由键决定特点):由键决定的特点: 有序、不重复、无索引
3. TreeMap (由键决定特点):按照大小默认升序排序、不重复、无索引。

HashMap集合、LinkedHashMap集合、TreeMap集合

HashMap： 无序、不重复、无索引

LinkedHashMap： 有序、不重复、无索引

TreeMap： 排序、不重复、无索引

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapTest {
    public static void main(String[] args) {
        //Map泛型有两个，分别代表  key , value 的数据类型

        //Map<String,Integer> map = new HashMap<>();//无序、不重复、无索引
        Map<String, Integer> map = new LinkedHashMap<>();//有序、不重复、无索引

        //入手人生第一台车车
        map.put("奥迪A4L",280000);
        map.put("宝马3系",330000);
        map.put("奔驰C260L",320000);
        map.put("吉利星瑞",150000);
        map.put("深蓝SL03",160000);
        map.put("吉利星越L",180000);

        System.out.println(map);
        //get(Object key)  根据  key,  拿到value
        Integer integer = map.get("吉利星瑞");
        System.out.println(integer);

        TreeMap<Integer,String> treeMap = new TreeMap<>();//排序、不重复、无索引
        treeMap.put(10,"JAVAEE01");
        treeMap.put(12,"JAVAEE03");
        treeMap.put(11,"JAVAEE02");
        treeMap.put(13,"JAVAEE04");
        treeMap.put(14,"JAVAEE05");
        treeMap.put(16,"JAVAEE07");
        System.out.println(treeMap);
        String s = treeMap.get(14);
        System.out.println(s);
    }
}

Map集合的常用方法

这段代码演示了使用HashMap类的一些常见操作。下面是对每个操作的注释：

1. 使用.put方法添加元素到Map中，其中键是汽车型号，值是价格。
2. 使用.size方法获取Map中元素的个数。
3. 使用.clear方法清空Map中的所有元素。
4. 使用.isEmpty方法检查Map是否为空。
5. 使用.get方法根据键获取对应的值。
6. 使用.remove方法根据键移除对应的键值对。
7. 使用.containsKey方法判断Map是否包含指定的键。
8. 使用.containsValue方法判断Map是否包含指定的值。
9. 使用.keySet方法获取Map中所有的键，并存储在一个Set集合中。
10. 使用.values方法获取Map中所有的值，并存储在一个Collection集合中。
11. 创建一个新的HashMap对象，并添加元素。
12. 创建另一个新的HashMap对象，并添加元素。

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> map = new HashMap<>();

        // 1. 添加元素：无序、不重复、无索引 .put
        map.put("奥迪A4L", 280000);
        map.put("宝马3系", 330000);
        map.put("奔驰C260L", 320000);
        map.put("吉利星瑞", 150000);
        map.put("深蓝SL03", 160000);
        map.put("吉利星越L", 180000);
        System.out.println(map);

        // 2. 获取元素个数
        System.out.println(map.size());

        // 3. 清空Map
        // map.clear();

        // 4. 判断Map是否为空
        System.out.println(map.isEmpty());

        // 5. 根据键获取对应的值
        System.out.println(map.get("吉利星瑞"));

        // 6. 根据键移除对应的键值对
        map.remove("奥迪A4L");
        System.out.println(map);

        // 7. 判断是否包含指定的键
        System.out.println(map.containsKey("深蓝SL03"));

        // 8. 判断是否包含指定的值
        System.out.println(map.containsValue(150000));

        // 9. 获取所有的键集合
        Set<String> set = map.keySet();
        System.out.println(set);

        // 10. 获取所有的值集合
        Collection<Integer> values = map.values();
        System.out.println(values);

        // 11. 创建一个新的HashMap，并添加元素
        HashMap<String, Integer> map1 = new HashMap<>();
        map1.put("宝马X1", 250000);
        System.out.println(map1);

        // 12. 创建另一个新的HashMap，并添加元素
        HashMap<String, Integer> map2 = new HashMap<>();
        map2.put("长安锐程PLUS", 120000);
        map2.put("长安UNT-V", 130000);
        System.out.println(map2);
    }
}

Map遍历方式 三种：(keySet)、(EntrySet)、(用匿名内部类写)

import jdk.swing.interop.SwingInterOpUtils;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;

public class MapDemo01 {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("奥迪A4L", 280000);
        map.put("宝马3系", 330000);
        map.put("奔驰C260L", 320000);
        map.put("吉利星瑞", 150000);
        map.put("深蓝SL03", 160000);
        map.put("吉利星越L", 180000);

        //Map集合的第一种遍历方式：通过Key获取所有元素
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            System.out.println("品牌："+key+"、落地价："+map.get(key));
        }

        System.out.println("=======================================");

        //Map集合的第二种遍历方式: 获健值对对象 Entry
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        for (Map.Entry<String, Integer> entry : entrySet) {
            System.out.println("品牌："+entry.getKey()+"、价格："+entry.getValue());
        }

        System.out.println("=======================================");

        //方法参数是抽象类、通过接口时：用匿名内部类写(可以点波浪线生成更好的代码)
        map.forEach(new BiConsumer<String, Integer>() {
            @Override
            public void accept(String s, Integer integer) {
                System.out.println("品牌："+s+"、价格："+integer);
            }
        });

        
    }
}

Map集合案例

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

public class MapListTest {
    public static void main(String[] args) {
        //随机生成80个学生的票数据
        //ArrayList集合，统计所有的投票
        ArrayList<String> list = new ArrayList<>();

        //HashMap集合，key是景点，vaLue是投票数
        Map<String, Integer> map = new HashMap<>();

        Random random = new Random();
        String[] attractions = {"西湖", "迦南", "温州", "重庆"};
        for (int i = 0; i <80 ; i++) {
            // 随机生成0、1、2、3
            int nextInt = random.nextInt(4);
            // 根据随机生成的数字作为下标获取景点，放到ArrayList集合中
            list.add(attractions[nextInt]);
        }

        // 遍历ArrayList集合，获取每一个投票景点
        for (String s : list) {
            // 如果当前景点已经统计过了
            if (map.containsKey(s)){
                // 取票数
                Integer integer = map.get(s);
                // 重新put静态，value 是票数加+1
                map.put(s,integer+1);
                // 否则记一票
            }else {
                map.put(s,1);
            }
        }
        System.out.println(map);
    }
}

---

Map集合嵌套

import java.util.*;
public class MapTest {
    public static void main(String[] args) {
        /**
* 目标：理解集合的嵌套。
* 江苏省 = "南京市","扬州市","苏州市“,"无锡市","常州市"
* 湖北省 = "武汉市","孝感市","十堰市","宜昌市","鄂州市"
* 河北省 = "石家庄市","唐山市", "邢台市", "保定市", "张家口市"
*/
        Map<String, List<String>> map = new HashMap<>();

        List<String> list = new ArrayList<>();
        Collections.addAll(list,"南京市","扬州市","苏州市","无锡市","常州市");
        map.put("江苏省",list);

        List<String> list1 = new ArrayList<>();
        Collections.addAll(list1,"武汉市","孝感市","十堰市","宜昌市","鄂州市");
        map.put("湖北省",list1);

        List<String> list2 = new ArrayList<>();
        Collections.addAll(list2,"石家庄市","唐山市", "邢台市", "保定市", "张家口市");
        map.put("河北省",list2);

        System.out.println(map);

        List<String> strings = map.get("湖北省");
        for (String s : strings) {
            System.out.println(s);
        }
    }
}

集合小案例练习题

Map使用

定义两个数组，完全按照以下内容和顺序

1. 第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]
2. 第二个数组为：[哈尔滨,杭州,南昌,广州,福州]

遍历数组放入Map中

• 要求：将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中
• 控制台遍历map并打印key、value信息，输出格式不做要求

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

public class MapDeno {
    public static void main(String[] args) {
        //定义一个集合
        Map<String, String> map = new HashMap<>();
        //定义两个数组
        String[] province = {"黑龙江","浙江省","江西省","广东省","福建省"};
        String[] city = {"哈尔滨","杭州","南昌","广州","福州"};

        //for循环遍历把数组写入集合
        for (int i = 0; i < province.length; i++) {
            map.put(province[i],city[i]);
        }
        //forEach遍历打印
        map.forEach(((s, s2) -> System.out.println("省份为："+s+"、地级市为："+s2)));

        System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++");

        //匿名内部类写法打印
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String s, String s2) {
                System.out.println("省份为："+s+"、地级市为："+s2);
            }
        });
    }
}

TreeMap使用

学生类

• 属性：姓名、地址、年龄

测试类：

• 使用TreeMap集合保存学生对象信息,要求创建不低于五个学生对象
• 集合添加元素时，要求以学生对象为键,住址为值
• TreeMap集合按照学生的年龄从大到小排序后，遍历集合并输出键值内容，输出格式不做要求

import jdk.swing.interop.SwingInterOpUtils;
import java.util.TreeMap;
import java.util.function.BiConsumer;

public class StudentMap {
    public static void main(String[] args) {
        TreeMap<Student, String> map = new TreeMap<>();
        map.put(new Student("陈某","黑马",20),"黑马");
        map.put(new Student("唐某","白马",19),"白马");
        map.put(new Student("周某","黄马",18),"黄马");
        map.put(new Student("林某","绿马",21),"绿马");
        map.put(new Student("杨某","蓝马",23),"蓝马");

        //forEach遍历打印出来
        map.forEach(((student, s) -> System.out.println(student+"-----"+s)));

        System.out.println("++++++++++++++++++++++++++++++++++++++++++++++");

        //匿名内部类方式打印出来
        map.forEach(new BiConsumer<Student, String>() {
            @Override
            public void accept(Student student, String s) {
                System.out.println(student+"-----"+s);
            }
        });

    }
}

class Student implements Comparable<Student> {
    private String name;
    private String address;
    private int age;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public int getAge() {
        return age;
    }

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

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

    @Override
    public int compareTo(Student o) {
        //从大到小排列
        return o.getAge() - getAge();
    }
}