java详解 --- Map接口

一.接口
Map接口中键和值一一映射. 可以通过键来获取值。
Map的结构:Map(key,value)(这里是一对<>) map = new Map<>();
key称为键值,value称为键对应值.
1.特点:
①.数据的保存是以键值对形式存储的(一个key对应一个value值 – 映射关系);
②.键是唯一的,不能重复的.

2.HashSet 和 HashMap 之间的关系
HashSet 底层的实现其实就是 HashMap,就是说HashSet依赖于HashMap,在HashSet添加值就是在HashMap中的key添加值.而去除重复和排序是对HashMap中的key进行操作的.
所以说,HashSet和HashMap的去重和排序都要重写HashCode()方法和equals()方法.

3.代码举例:
①.在map中保存4对键对值 姓名 年龄

HashMap<String, Integer> map = new HashMap<>();
map.put("张三", 18);
map.put("李四", 19);
map.put("王二", 20);
map.put("麻子", 21);
// 键值还有一个,输出value数覆盖后的值
map.put("麻子", 22);
System.out.println(map);

输出结果:

{李四=19, 张三=18, 麻子=22, 王二=20}

②.测试map的各种方法

        HashMap<String, Integer> map = new HashMap<>();
        map.put("张三", 18);
        map.put("李四", 19);
        map.put("王二", 20);
        map.put("麻子", 21);

        // 测试containsKey(Object key)
        // 测试是否包含key值
        boolean containsKey = map.containsKey("李四");
        System.out.println("1." + containsKey);

        // 测试containsValue(Object Value)
        // 测试是否包含value值
        boolean containsValue = map.containsValue(20);
        System.out.println("2." + containsValue);

        // 测试isEmpty()
        // 测试map集合是否是空的
        boolean empty = map.isEmpty();
        System.out.println("3." + empty);

        // 测试size()
        // 测试map集合的长度
        int size = map.size();
        System.out.println("4." + size);

        // 测试remove(Object key)
        // 测试删除对应的键值
        map.remove("李四");
        System.out.println("5." + map);

        // 测试clear()
        // 测试清空map集合
        map.clear();
        System.out.println("6." + map);

输出结果:

1.true
2.true
3.false
4.4
5.{张三=18, 麻子=21, 王二=20}
6.{

}

③.创建Map
key保留学生 value保存学生的户籍
先写一个学生类:

public class Student implements Comparable<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 + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public int compareTo(Student o) {
        int num = this.age - o.age;
        return num == 0 ? 1 : num;
    }

}

写main函数部分

        HashMap<Student, String> map = new HashMap<>();
        map.put(new Student("张三", 18), "北京");
        map.put(new Student("李四", 19), "上海");
        map.put(new Student("王二", 20), "广州");
        // 键不会重复保存 但是 会覆盖上一个值
        map.put(new Student("王二", 20), "南京");
        System.out.println(map);

输出结果:

{Student [name=王二, age=20]=南京, Student [name=张三, age=18]=北京, Student[name=李四, age=19]=上海}

二.Map的三种遍历方式

1.迭代器遍历

        HashMap<String, Integer> map = new HashMap<>();
        map.put("s1",15);
        map.put("s2",16);
        map.put("s3",17);
        map.put("s4",18);
        // 取出map中的键值的set集合
        Set<String> set = map.keySet();
        // 取出set中的迭代器
        Iterator<String> iterator = set.iterator();
        // 为拿到所有key遍历set集合
        while (iterator.hasNext()) {
            // 获取集合中的所有key值
            String key = iterator.next();
            // 根据key值取出对应的Value值
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }

输出结果:

s3 = 17
s4 = 18
s1 = 15
s2 = 16

2.增强for循环遍历

        HashMap<String, Integer> map = new HashMap<>();
        map.put("s1",15);
        map.put("s2",16);
        map.put("s3",17);
        map.put("s4",18);
        // 取出map中的key的所有set集合
        Set<String> set = map.keySet();
        for (String key : set) {
            Integer value = map.get(key);
            System.out.println(key + " = " + value);
        }

输出结果:

s3 = 17
s4 = 18
s1 = 15
s2 = 16

3.entrySet方法

        HashMap<String, Integer> map = new HashMap<>();
        map.put("s1",15);
        map.put("s2",16);
        map.put("s3",17);
        map.put("s4",18);
        // 取出map中的所有的entrySet()
        Set<Entry<String, Integer>> entrySet = map.entrySet();
        // 取出迭代器
        Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
        while (iterator.hasNext()) {
            // 取出所有的entry对象 与键值对应
            Entry<String, Integer> entry = iterator.next();
            // 从entry中取出key 和 value
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }

输出结果:

s3 = 17
s4 = 18
s1 = 15
s2 = 16

④.利用entry()方法 增强for循环遍历

        HashMap<String, Integer> map = new HashMap<>();
        map.put("s1",15);
        map.put("s2",16);
        map.put("s3",17);
        map.put("s4",18);
        Set<Entry<String, Integer>> entrySet = map.entrySet();
        for (Entry<String, Integer> entry : entrySet) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + " = " + value);
        }

输出结果:

s3 = 17
s4 = 18
s1 = 15
s2 = 16

⑤.LinkedHashMap
特点:怎么存怎么取

        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        map.put("s1",15);
        map.put("s2",16);
        map.put("s3",17);
        map.put("s4",18);
        System.out.println(map);

输出结果:
{s1=15, s2=16, s3=17, s4=18}

⑥.TreeMap 可以对map中的键进行排序
向TreeMap中添加3个学生 key是学生 value是户籍
并按年龄排序.

学生类可以看一,3,③中的学生类
实现了comparable的方法并重写了compareTo方法

        TreeMap<Student,String> map = new TreeMap<>();
        map.put(new Student("s1", 18), "北京");
        map.put(new Student("s2", 19), "上海");
        map.put(new Student("s3", 20), "广州");
        System.out.println(map);

输出结果:

{Student [name=s1, age=18]=北京, Student [name=s2, age=19]=上海,Student[name=s3, age=20]=广州}

三.Map的嵌套

简单理解就是Map里面套了一个Map
代码举例:
java学科有两个班:
java1班 – 学生 和 户籍
java2班 – 学号 和 户籍

        // 创建1班
        HashMap<Student, String> c1 = new HashMap<>();
        c1.put(new Student("张三", 18), "北京");
        c1.put(new Student("李四", 19), "上海");
        // 创建2班
        HashMap<Student, String> c2 = new HashMap<>();
        c2.put(new Student("王二", 20), "广州");
        c2.put(new Student("麻子", 21), "南京");
        // 创建java学科
        HashMap<HashMap<Student, String>, String> java = new HashMap<>();
        java.put(c1, "1班");
        java.put(c2, "2班");
        // 遍历java学科
        for (HashMap<Student, String> c : java.keySet()) {
            // java中对应的value -- 对应的班级
            String ban = java.get(c);
            System.out.println(ban);
            for (Student student : c.keySet()) {
                // c中对应的value -- 对应的户籍
                String HJ= c.get(student);
                System.out.println(student + " -- " + HJ);
            }
        }

输出结果:

1班
Student [name=张三, age=18] – 北京
Student [name=李四, age=19] – 上海
2班
Student [name=王二, age=20] – 广州
Student [name=麻子, age=21] – 南京