Map的实现类HashMap与TreeMap讲解

---

1. Map 集合

1.1 Map集合概述和特点

• Map集合概述

interface Map<K,V>  K: 键的类型； V：值的类型

• Map集合特点
  双列集合，一个键对应着一个值
  键不可以重复，值可以重复
  （键+值）这个整体我们称为“键对值”或者”键对值对象”，在java中我们叫做“Entry对象”。
• Map集合的基本使用

public static void main(String[] args) {
    Map<String,String> map = new HashMap<>();
    map.put("小白","java");
    map.put("小黑","c");
    map.put("小美","java");
    map.put("小智","c");
    System.out.println(map);
}

1.2 Map集合的基本功能

• 方法介绍

方法名	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue（Object value）	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，集合中包含的键值对的个数

• 示例代码

public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();

        map.put("小白","java");
        map.put("小黑","css");
        map.put("小美","html");
        map.put("小智","c");
// 单个执行
//        method1(map);
//        method2(map);
//        method3(map);
//        method4(map);
//        method5(map);
//        method6(map);
//        method7(map);
    }
    private static void method7(Map<String, String> map) {
        int size = map.size();
        System.out.println(size);// 4
    }
    
    private static void method6(Map<String, String> map) {
        boolean empty = map.isEmpty();
        System.out.println(empty);// false
        map.clear();
        boolean empty1 = map.isEmpty();
        System.out.println(empty1);//true
    }

    private static void method5(Map<String, String> map) {
        boolean retContainsV = map.containsValue("java");
        boolean retContainsV1 = map.containsValue("java1");
        System.out.println(retContainsV);//true
        System.out.println(retContainsV1);// false
    }

    private static void method4(Map<String, String> map) {
        boolean retContainsK = map.containsKey("小白");
        boolean retContainsK1 = map.containsKey("小王八");
        System.out.println(retContainsK);// true
        System.out.println(retContainsK1);// false
    }

    private static void method3(Map<String, String> map) {
        map.clear();

        System.out.println(map);//{}
    }

    private static void method2(Map<String, String> map) {
        String retRemove = map.remove("小白");
        System.out.println(retRemove);//java
        System.out.println(map);//{小智=c, 小美=html, 小黑=css}
    }

    private static void method1(Map<String, String> map) {
        // 如果添加的键是存在的，就会覆盖原先的值，并把原先的值返回
        String retMap = map.put("小白", "python");//java
        System.out.println(retMap);
        System.out.println(map);//{小智=c, 小美=html, 小白=python, 小黑=css}
    }

1.3 Map集合的过去功能

• 方法介绍

方法名	说明
V get(Object key)	根据键获取值
Set keySet()	获取所有键的集合
Collection values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

• 遍历map集合

方法1：
创建一个集合添加元素–创建对象，put()
获取所有的键–keySet()
让每一个键找到自己对应的值 --get()
打印得到键和值-- 输出语句

public static void main(String[] args) {
    Map<String,String> map = new HashMap<>();

    map.put("小白","java");
    map.put("小黑","css");
    map.put("小美","html");
    map.put("小智","c");

    Set<String> keys = map.keySet();
    for (String string : keys) {
        String value = map.get(string);
        System.out.println(value);
        /*c
        html
        java
        css*/
    }
}

方法2：
创建一个集合添加元素–创建对象，put()
获取到所有的键值对 -> entrySet()
找到每一个键值对中的键和值-> getKey、getVale
打印键值对

public static void main(String[] args) {
    Map<String,String> map = new HashMap<>();

    map.put("小白","java");
    map.put("小黑","css");
    map.put("小美","html");
    map.put("小智","c");
    // Entry:Map接口的内部接口
    // Set集合中装的是键值对对象(Entry对象）
    // Entry里面装的是键和值
    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);
    }
}

2. HashMap集合

2.1 HashMap集合概述和特点

• HashMap底层是哈希表结构的
• 如果存储的是自定义对象需要重写hashCode和equals方法

2.2 HashMap底层原理

2.3 HashMap案例

案例：创建一个HashMap集合，键是学生对象（Student），值是籍贯（String）。存储三个键值对对象，并遍历。
学生类

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 boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Student student = (Student) o;

    if (age != student.age) return false;
    return name != null ? name.equals(student.name) : student.name == null;
}

@Override
public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + age;
    return result;
}
}

测试类

public static void main(String[] args) {
    HashMap<Student, String> hm = new HashMap<>();
    Student student1 = new Student("小红", 33);
    Student student2 = new Student("小明", 12);
    Student student3 = new Student("小黑", 45);
    hm.put(student1, "优");
    hm.put(student2, "良");
    hm.put(student3, "差");

    // 第一种，先获取所有的键，在通过每一个键来找对应的值
    Set<Student> keys = hm.keySet();
    for (Student key : keys) {
        System.out.println(hm.get(key));
    }
    System.out.println("<><><><><><><><><><><><>");
    Set<Map.Entry<Student, String>> entries = hm.entrySet();
    for (Map.Entry<Student, String> entry : entries) {
        System.out.println(entry.getKey().getName() + ":" + entry.getValue());
    }
    System.out.println("<><><><><><><><><><><><>");
    hm.forEach((Student s,String str)-> {
        System.out.println(s.getName() + ":" + str);
    });
}

• map集合遍历之 forEach
  

3. TreeMap集合

3.1 TreeMap集合概述和特点

• TreeMap底层是红黑树结构
• 依赖自然排序或者比较器排序，对键进行排序
• 如果键存储的是自定义对象，需要实现Comparable接口或者在创建TreeMap对象的时候给出比较器的排序规则。
  TreeMap与TreeSet集合底层原理类似，知识TreeMap在添加元素只关心键，不关心值。具体请参考HashSet底层原理图解
  3.2 TreeMap 集合应用案例
• 案例需求
  创建一个TreeMap集合，键是学生对象，属性是姓名和年龄，按照年龄进行排序
  要求按照学生年龄进行排序，如果年龄相同则按照姓名进行排序
• 代码实现
  学生类

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 compareTo(Student o) {
        //按照年龄进行排序
        int result = o.getAge() - this.getAge();
        //次要条件，按照姓名排序。
        result = result == 0 ? o.getName().compareTo(this.getName()) : result;
        return result;
    }
}

测试类

    public class Test1 {
    public static void main(String[] args) {
    // 创建TreeMap集合对象
    TreeMap<Student,String> tm = new TreeMap<>();
     // 创建学生对象
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",22);
        Student s3 = new Student("xiaomei",22);
      
        // 将学生对象添加到TreeMap集合中
        tm.put(s1,"江苏");
        tm.put(s2,"北京");
        tm.put(s3,"天津");
      
        // 遍历TreeMap集合,打印每个学生的信息
        tm.forEach(
                (Student key, String value)->{
                    System.out.println(key + "---" + value);
                }
        );
    }
}

---