Map集合的特点以及遍历方式

---

前言

这篇文章主要介绍了Map集合的遍历方式和简单的底层原理
遍历时候需要了解一下Map集合的方法，所有需要先学习一下Map方法。

---

一、认识Map集合

Map集合称为双列集合，一次需要存一对数据做为一个元素, 格式：{key1=value1 , key2=value2 , key3=value3 , …}
Map集合的每个元素分为两部分:key和value，key称为键，value称为值，整体叫键值对，因此Map也叫“键值对集合”
Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值

二、Map集合体系

体系图

Map集合体系的特点

HashMap: 无序、不重复 （用的最多）
LinkedHashMap ：有序、不重复
TreeMap: 按照大小默认升序排序、不重复

三、Map集合常用方法

public V put(K key,V value) 添加/修改元素
public int size() 获取集合的大小
public void clear() 清空集合
public boolean isEmpty() 判断集合是否为空
public V get(Object key) 根据键获取对应值
public V remove(Object key) 根据键删除整个元素
public boolean containsKey(Object key) 判断是否包含某个键
public boolean containsValue(Object value) 判断是否包含某个值
public Set keySet() 获取全部键的集合
public Collection values() 获取Map集合的全部值

  //向map中存入西游四人组的编号和姓名 001-玄奘  002-悟空  003-悟能  004-悟净
        Map<String, String> map = new HashMap<>();
        //V put(K key,V value)   添加元素
        map.put("001","玄奘");
        map.put("002","悟空");
        map.put("003","悟能");
        map.put("004","悟净");
        //int size()	获取集合的大小
        System.out.println(map.size());
        //boolean isEmpty()	判断集合是否为空，为空返回true, 反之
        System.out.println(map.isEmpty());
        //V get(Object key)	根据键获取对应值
        System.out.println(map.get("002"));
        //V remove(Object key)	根据键删除整个元素
        System.out.println(map.remove("001"));
        //boolean containsKey(Object key)	  判断是否包含某个键
        System.out.println(map.containsKey("001"));
        //boolean containsValue(Object value)	  判断是否包含某个值
        System.out.println(map.containsValue("悟净"));
        //Set<K> keySet()	 获取全部键的集合
        System.out.println(map.keySet());
        //Collection<V> values()	 获取Map集合的全部值
        System.out.println(map.values());
        //void clear()	清空集合
        map.clear();

四、Map集合的遍历

遍历方式一

首先要学一个方法：

public Set keySet() 获取所有键的集合

根据键使用增强for遍历所需要的值

HashMap<String, String> map = new HashMap<>();
        map.put("001", "玄奘");
        map.put("002", "悟空");
        map.put("003", "悟能");
        map.put("004", "悟净");
        test1(map);
        private static void test1(HashMap<String, String> map) {
        Set<String> strings = map.keySet();
        for (String key:strings) {
            System.out.println(map.get(key));
        }
    }

遍历方式二

先学方法

Set<Map.Entry<K, V>> entrySet() 获取所有“键值对”的集合
K getKey() 获取键
V getValue() 获取值

 HashMap<String, String> map = new HashMap<>();
        map.put("001", "玄奘");
        map.put("002", "悟空");
        map.put("003", "悟能");
        map.put("004", "悟净");
        test2(map);
        private static void test2(HashMap<String, String> map) {
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getValue());
        }
    }

遍历方式三

使用lambda表达式遍历

 HashMap<String, String> map = new HashMap<>();
        map.put("001", "玄奘");
        map.put("002", "悟空");
        map.put("003", "悟能");
        map.put("004", "悟净");
        test3(map);
        private static void test3(HashMap<String, String> map) {
        map.forEach((k,v)-> System.out.println(v));
    }

五、HashMap

底层原理

HashMap跟HashSet的底层原理是一模一样的，都是基于哈希表实现的。
实际上：原来学的Set系列集合的底层就是基于Map实现的，只是Set集合中的元素只要键数据，不要值数据而已。
JDK8之前，哈希表 = 数组+链表
JDK8开始，哈希表 = 数组+链表+红黑树
哈希表是一种增删改查数据，性能都较好的数据结构。

HashMap的特点

HashMap集合是一种增删改查数据，性能都较好的集合
但是它是无序，不能重复，没有索引支持的（由键决定特点）

HashMap的键依赖hashCode方法和equals方法保证键的唯一
如果键存储的是自定义类型的对象，可以通过重写hashCode和equals方法，这样可以保证多个对象内容一样时，HashMap集合就能认为是重复的。

public class Demo4 {
    public static void main(String[] args) {
        //1. 创建一个Map集合
        HashMap<Student, String> map = new HashMap<>();
        map.put(new Student("李四",13),"北京");
        map.put(new Student("李一",13),"上海");
        map.put(new Student("李三",13),"深圳");
        map.put(new Student("李三",13),"广州");
        //2. 存储三个学生和地址
        Set<Student> students = map.keySet();
        for (Student stu:students){
            System.out.println(stu+map.get(stu));
        }
        //3. 遍历打印
    }
}

class Student {

    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, 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 +
                '}';
    }

}

六、LinkedHashMap

底层原理

底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序(保证有序)
实际上：原来学习的LinkedHashSet集合的底层原理就是LinkedHashMap

LinkedHashMap的特点

LinkedHashMap : 有序、不重复

  public static void main(String[] args) {
        //创建LinkedHashMap
        LinkedHashMap<String, String> map = new LinkedHashMap<>();
        map.put("001","Aa");
        map.put("002","Bb");
        map.put("003","Cc");
        map.put("003","dd");
        //保存数据
        System.out.println(map);
        //观察顺序
    }

七、TreeMap

底层原理

原理：TreeMap跟TreeSet集合的底层原理是一样的，都是基于红黑树实现的排序。

TreeMap的特点

不重复、无索引、可排序(按照键的大小默认升序排序，只能对键排序)

TreeMap集合同样也支持两种方式来指定排序规则
让类实现Comparable接口，重写比较规则。
TreeMap集合有一个有参数构造器，支持创建Comparator比较器对象，以便用来指定比较规则。

public class Demo6 {
    private String put;

    public static void main(String[] args) {
        //创建集合
        Map<Teacher, String> map = new TreeMap<>((o1, o2) -> o1.getAge() > o2.getAge() ? 1:-1);
        map.put(new Teacher("张三", 21), "河北");
        map.put(new Teacher("李四", 20), "山东");
        map.put(new Teacher("王五", 19), "山西");
        map.put(new Teacher("赵六", 21), "河南");
        map.forEach((k, v) -> {
            if ("王五".equals(k.getName())){
                map.remove(k);
            }
            System.out.println(k + "-----" + v);
        });
        
        map.forEach((k, v) -> {

            System.out.println(k + "-----" + v);
        });
    }
}

class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(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 "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Teacher teacher = (Teacher) o;
        return age == teacher.age && Objects.equals(name, teacher.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

总结

在Java中，Map接口是一个双列集合，用于存储键-值对（key-value pairs）。每个键都是唯一的，而一个键可以对应一个值。Map接口提供了插入、删除、更新和查询键值对的操作。Java标准库中几个常见的实现类包括：
HashMap：基于哈希表实现，无序，允许一个null键和多个null值，非线程安全，查询速度快，是最常用的Map实现类。
LinkedHashMap：基于哈希表和双向链表实现，有序（按照插入顺序或访问顺序），其他特性和HashMap相同，适合需要保持插入或访问顺序的场景。
TreeMap：基于红黑树实现，键需实现Comparable或提供Comparator，保证键的自然排序或定制排序，因此它是有序的，适用于需要按键排序的场景