Map集合(HashMap)&遍历(entrySet)

1.概述

Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储

Map中的集合，元素是成对存在的（理解为夫妻），每个元素由键与值两部分组成，通常键可以找到对应的值

Collection中的集合称为单列集合，Map中的集合称为双列集合

需要注意的是，Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值

java.util.Map<k,v>集合

Map集合的特点：

（1）Map集合是一个双列集合，一个元素包含两个值（一个key，一个value）

（2）Map集合中的元素，key和value的数据类型可以相同，也可以不同

（3）Map集合中的元素，key是不允许重复的，value是可以重复的

（4）Map集合中的元素，key和value是一一对应的

2.Map常用的子类

（1）HashMap集合

java.util.HashMap<k,v>集合 implements Map<k, v>接口

HashMap集合的特点：

HashMap集合底层是哈希表：查询的速度特别快，

　　JDK1.8之前：数组+单向链表

　　JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）

　　为什么用红黑树？提高查询速度

HashMap集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致

（2）LinkedHashMap集合

哈希表和链表实现的Map接口，具有可预测的迭代次序。

java.util.LinkedHashMap<k, v>集合 extends HashMap<k, v>集合

LinkedHashMap集合的特点：

LinkedHashMap集合底层是哈希表+链表（链表是为了保证迭代的顺序）

LinkedHashMap集合是一个有序的集合，存储元素和取出元素的顺序是一致的

3.Map接口中常用的方法

（1）put

public V put(K key, V value):把指定的键与指定的值添加到Map集合中

　　返回值：v

　　　　存储键值对的时候，key不重复，返回值V是null

　　　　存储键值对的时候，key重复，会使用新的value替换map中重复的value，返回被替换的value值

key不重复的时候：

运行结果：

key重复的时候：

运行结果：

一般情况下，返回值V无需接收

（2）remove

public V remove(Object key):把指定的键，所对应的键值元素在Map集合中删除，返回被删除的元素

　　返回值：V

　　　　key存在，v返回被删除的值

　　　　key不存在，v返回null

运行结果：

（3）get

public V get(Object key) 根据指定的键，在Map集合中获取对应的值

　　　返回值：

　　　　key存在，返回对应的value值

　　　　key不存在，返回null

（4）containsKey

boolean containsKey(Object key)判断集合中是否包含指定的键

包含返回true，不包含返回false

运行结果：

4.Map集合遍历找值

（1）Map集合的第一种遍历方式：通过键找值的方式

Map集合中的方法：

Set<K> keySet()返回此映射中包含的键的Set视图

实现步骤：

使用Map集合中的方法keySet()，把Map集合所有的key取出来，存储到一个Set集合中
遍历Set集合，获取Map集合中的每一个key
通过Map集合中的方法get(key)，通过key找到value

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

public class Demo02KeySet {
    public static void main(String[] args) {
        // 创建Map集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("张天爱", 165);
        map.put("林志玲", 178);

        // 使用Map集合中的方法keySet()，把Map集合所有的key取出来，存储到一个Set集合中
        Set<String> set = map.keySet();

        // 遍历set集合，获取Map集合中的每一个key
        Iterator<String> iterator = set.iterator();
        while (iterator.hasNext()) {
            String key = iterator.next();
            // 通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }
        System.out.println("==============================");

        // 使用增强for遍历set集合
        for (String key : set) {
            // 通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key + "=" + value);
        }

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

        // 增强for循环set集合
        for (String key : map.keySet()) {
            // 通过Map集合中的方法get(key),通过key找到value
            Integer value = map.get(key);
            System.out.println(key + "=" + value);

        }
    }
}

　运行结果

（2）Map集合遍历键值对方式

Map.Entry<K,V>在Map接口中有一个内部接口Entry

作用：当Map集合一创建，那么就会在Map集合中创建一个Entry对象，用来记录键与值（键值对对象，键与值的映射关系），多个键值对，就有多个Entry对象----》结婚证

Map集合中的方法：

　　Set<Map.Entry<K, V>> entrySet() 返回此映射中包含的映射关系的Set视图

实现步骤：

使用Map集合中的方法entrySet()方法，把Map集合多个Entry对象取出来，存储到一个Set集合中
遍历Set集合，获取每一个Entry对象
使用Entry对象中的方法getKey()和getValue()获取键与值

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

public class Demo03EntrySet {
    public static void main(String[] args) {
        // 创建Map集合对象
        Map<String, Integer> map = new HashMap<>();
        map.put("赵丽颖", 168);
        map.put("张天爱", 165);
        map.put("林志玲", 178);

        Set<Map.Entry<String, Integer>> set = map.entrySet();

        // 使用迭代器遍历set
        Iterator<Map.Entry<String, Integer>> iterator = set.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> entry = iterator.next();
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }

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

        // 使用增强for循环遍历
        for (Map.Entry<String, Integer> entry : set) {
            String key = entry.getKey();
            Integer value = entry.getValue();
            System.out.println(key + "=" + value);
        }

    }
}

　　运行结果：

5.HashMap存储自定义键值类型

HashMap存储自定义类型键值

Map集合保证key是唯一的：

　　作为key的元素，必须重写hashCode方法和equals方法，以保证key唯一

运行结果：

下面的写法并不能保证key唯一

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", 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;
    }
}

运行结果：

因为自定义类型Person类没有重写hashCode和equals，所以不能保证key唯一

下面修改

package com.company.service.TestMap;

import java.util.Objects;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

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

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

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

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

　　重写hashCode和equals