黯相望。断鸿声里，立尽斜阳。

——柳永《玉蝴蝶》

Map接口及其实现类

1. Map接口介绍

现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即 java.util.Map 接口。

Map与Collection并列存在。用于保存具有映射关系的数据:key-value。

Map 中的 key 和 value 都可以是任何引用类型的数据

Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法

常用String类作为Map的“键”。

key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value。

Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数据类型可以相同，也可以不同。

Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。其中HashMap是 Map 接口使用频率最高的实现类

在这里插入图片描述

2. Map接口中常用方法

元素的添加、删除、修改操作

Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中。

void putAll(Map m):将m中的所有key-value对存放到当前map中。

Object remove(Object key)：移除指定key的key-value对，并返回value。

void clear()：清空当前map中的所有数据。

元素查询的操作

Object get(Object key)：获取指定key对应的value。

boolean containsKey(Object key)：是否包含指定的key。

boolean containsValue(Object value)：是否包含指定的value。

int size()：返回map中key-value对的个数。

boolean isEmpty()：判断当前map是否为空。

boolean equals(Object obj)：判断当前mp和参数对象obj是否相等。

遍历Map的三种方式☆

public Set<K> keySet() : 获取Map集合中所有的键，存储到Set集合中。

获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示: keyset()

遍历键的Set集合，得到每一个键。

根据键，获取键所对应的值。方法提示: get(K key)

Collection values()：返回所有value构成的Collection集合

public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。

我们已经知道， Map 中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在在 Map 中是一一对应关系，这一对对象又称做 Map 中的一个 Entry(项) 。 Entry 将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历 Map 集合时，就可以从每一个键值对（ Entry ）对象中获取对应的键与对应的值。既然Entry表示了一对键和值，那么也同样提供了获取对应键和对应值得方法：

Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

public K getKey() ：获取Entry对象中的键。

public V getValue() ：获取Entry对象中的值。

/**
 * @Date 2020/11/13 17:29
 * @Version 10.21
 * @Author DuanChaojie
 */
public class TestMap {
    public static void main(String[] args) {
        // 集合初始化时，指定集合初始值大小
        // 说明:HashMap使用如下构造方法进行初始化，如果暂时无法确定集合大小，那么指定默认值（16）即可
        Map map = new HashMap();
        //map.put(..,..)省略
        
        System.out.println("map的所有key:");
        // HashSet
        Set keys = map.keySet();
        for (Object key : keys) {
            System.out.println(key + "->" + map.get(key));
        }
        
        System.out.println("map的所有的value：");
        Collection values = map.values();
        Iterator iter = values.iterator();
        while (iter.hasNext()) {
            System.out.println(iter.next());
        }
        
        System.out.println("map所有的映射关系：");
        // 映射关系的类型是Map.Entry类型，它是Map接口的内部接口
        Set mappings = map.entrySet();
        for (Object mapping : mappings) {
            Map.Entry entry = (Map.Entry) mapping;
            System.out.println("key是：" + entry.getKey() + "，value是：" + entry.getValue());
        }
    }
}

3. Map接口的实现类

3.1 HashMap集合

HashMap是 Map 接口使用频率最高的实现类。

允许使用null键和null值，与HashSet一样，不保证映射的顺序。

所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()。

所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类要重写：equals()。

==一个key-value构成一个entry==

所有的entry构成的集合是Set:无序的、不可重复的

HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。

因为key不允许有重复。

HashMap 判断两个 value 相等的标准是：两个 value 通过 equals() 方法返回 true。

HashMap源码中的重要常量☆

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16

MAXIMUM_CAPACITY ： HashMap的最大支持容量，2^30

DEFAULT_LOAD_FACTOR ：HashMap的默认加载因子0.75

TREEIFY_THRESHOLD ：Bucket中链表长度大于该默认值8，转化为红黑树

UNTREEIFY_THRESHOLD ：Bucket中红黑树存储的Node小于该默认值6，转化为链表。

MIN_TREEIFY_CAPACITY ：==桶中的Node被树化时最小的hash表容量==。（当桶中Node的数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值（默认为64）至少是TREEIFY_THRESHOLD的4倍。）

table ：存储元素的数组，总是2的n次幂

entrySet： 存储具体元素的集

size ：HashMap中存储的键值对的数量

modCount ：HashMap扩容和结构改变的次数。

threshold ：扩容的临界值（吞吐临界值）12=容量*填充因子

loadFactor： 填充比（负载因子）。

负载因子值的大小，对HashMap有什么影响？

负载因子的大小决定了HashMap的数据密度。

负载因子越大密度越大，发生碰撞的几率越高，数组中的链表越容易长,造成查询或插入时的比较次数增多，性能会下降。

负载因子越小，就越容易触发扩容，数据密度也越小，意味着发生碰撞的几率越小，数组中的链表也就越短，查询和插入时比较的次数也越小，性能会更高。但是会浪费一定的内容空间。而且经常扩容也会影响性能，建议初始化预设大一点的空间。

按照其他语言的参考及研究经验，会考虑将负载因子设置为0.7~0.75，此时平均检索长度接近于常数。

HashMap的储存结构☆☆

JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法)。

JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。

JDK7

HashMap的内部存储结构其实是数组和链表的结合。当实例化一个HashMap时，系统会创建一个长度为Capacity的Entry数组，这个长度在哈希表中被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为“桶”(bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。

每个bucket中存储一个元素，即一个Entry对象，但每一个Entry对象可以带一个引用变量，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Entry链。而且新添加的元素作为链表的head。
HashMap静态内部类Entry
1
2
3
4
5
6
7
static class Entry<K,V> implements Map.Entry<K,V> {
       final K key;
       V value;
       final int hash;
       Entry<K,V> next;
    	// ....
}
==添加元素的过程：==

向HashMap中添加entry1(key，value)，需要首先计算entry1中key的哈希值(根据key所在类的hashCode()计算得到)，此哈希值经过处理以后，得到在底层Entry[]数组中要存储的位置i。

如果位置i上没有元素，则entry1直接添加成功。如果位置i上已经存在entry2(或还有链表存在的entry3，entry4)，则需要通过循环的方法，依次比较entry1中key和其他的entry。如果彼此hash值不同，则直接添加成功。

如果hash值不同，继续比较二者是否equals。如果返回值为true，则使用entry1的value
去替换equals为true的entry的value。

如果遍历一遍以后，发现所有的equals返回都为false,则entry1仍可添加成功。entry1指向原有的entry元素。

==HashMap 的扩容：==

当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

那么HashMap 什么时候进行扩容呢？

当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)loadFactor 时，就会进行数组扩容， loadFactor 的默认值(DEFAULT_LOAD_FACTOR)为0.75，这是一个折中的取值。

也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

JDK8

HashMap的内部存储结构其实是 数组+ 链表+ 树 的结合。当实例化一个HashMap时，会初始化initialCapacity和loadFactor，在put第一对映射关系时，系统会创建一个长度为initialCapacity的Node数组，这个长度在哈希表中被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为
“桶”(bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。

每个bucket中存储一个元素，即一个Node对象，但每一个Node对象可以带一个引用变量next，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Node链。也可能是一个一个TreeNode对象，每一个TreeNode对象可以有两个叶子结点left和right，因此，在一个桶中，就有可能生成一个TreeNode树。而新添加的元素作为链表的last，或树的叶子结点。
HashMap的静态内部类Node
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
   
    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }
   
    public final K getKey()        { return key; }
    public final V getValue()      { return value; }
    public final String toString() { return key + "=" + value; }
   
    public final int hashCode() {
        return Objects.hashCode(key) ^ Objects.hashCode(value);
    }
   
    public final V setValue(V newValue) {
        V oldValue = value;
        value = newValue;
        return oldValue;
    }
   
    public final boolean equals(Object o) {
        if (o == this)
            return true;
        if (o instanceof Map.Entry) {
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            if (Objects.equals(key, e.getKey()) &&
                Objects.equals(value, e.getValue()))
                return true;
        }
        return false;
    }
}
那么HashMap 什么时候进行扩容和树形化呢？

当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)loadFactor 时，就会进行数组扩容， loadFactor 的默认值(DEFAULT_LOAD_FACTOR)为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

当HashMap中的其中一个链的对象个数如果达到了8个，此时如果capacity没有达到64，那么HashMap会先扩容解决，如果已经达到了64，那么这个链会变成树，结点类型由Node变成TreeNode类型。当然，如果当映射关系被移除后，下次resize方法时判断树的结点个数低于6个，也会把树再转为链表。

如果不理解这段，可以看一下HashMap源码中的重要常量MIN_TREEIFY_CAPACITY 。

关于映射关系的key 是否可以修改？

答案是：不要修改！

映射关系存储到HashMap中会存储key的hash值，这样就不用在每次查找时重新计算每一个Entry或Node（TreeNode）的hash值了，因此如果已经put到Map中的映射关系，再修改key的属性，而这个属性又参与hashcode值的计算，那么会导致匹配不上。

小结

JDK1.8相较于之前的变化：

HashMap map = new HashMap();//默认情况下，先不创建长度为16的数组。

当首次调用map.put()时，再创建长度为16的数组。

数组为Node类型，在jdk7中称为Entry类型。

形成链表结构时，新添加的key-value对在链表的尾部（七上八下）。

当数组指定索引位置的链表长度>8时，且map中的数组的长度> 64时，此索引位置上的所有key-value对使用红黑树进行存储。

HashMap存储自定义类型键值

每位学生（姓名，年龄）都有自己的家庭住址。那么，既然有对应关系，则将学生对象和家庭住址存储到map集合中。学生作为键, 家庭住址作为值。

注意，学生姓名相同并且年龄相同视为同一名学生。

Student.java

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

测试类HashMapTest

public class HashMapTest {
    
    public static void main(String[] args) {
        //1,创建Hashmap集合对象。
        Map<Student,String>map = new HashMap<Student,String>();
        
        //2,添加元素。
        map.put(newStudent("lisi",28), "上海");
        map.put(newStudent("wangwu",22), "北京");
        map.put(newStudent("zhaoliu",24), "成都");
        map.put(newStudent("zhouqi",25),"广州");
        map.put(newStudent("wangwu",22), "南京");
        
        //3,取出元素。键找值方式
        Set<Student>keySet = map.keySet();
        for(Student key: keySet){
            Stringvalue = map.get(key);
            System.out.println(key.toString()+"....."+value);
        }
    }
}

当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。

如果要保证map中存放的key和取出的顺序一致，可以使用 java.util.LinkedHashMap 集合来存放。

LinkedHashMap集合☆

我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？

LinkedHashMap 是 HashMap 的子类，它是链表和哈希表组合的一个数据存储结构。

public class LinkedHashMapDemo {
    public static void main(String[] args) {
        LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
        map.put("邓超", "孙俪");
        map.put("李晨", "范冰冰");
        map.put("刘德华", "朱丽倩");
        Set<Entry<String, String>> entrySet = map.entrySet();
        
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }
    }
}

结果：

1
2
3

邓超 孙俪
李晨 范冰冰
刘德华 朱丽倩

LinkedHashMap的静态内部类Entry

static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after;
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}

3.2 TreeMap集合

TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。

TreeSet底层使用红黑树结构存储数据。

TreeMap 的 Key 的排序：

自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException。

定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口

TreeMap判断两个key 相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

3.3 HashTable集合

HashTable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。

Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。

与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value

与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序

Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。

Properties类

Properties 类是 Hashtable 的子类，该对象用于处理属性文件由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key和 value 都是字符串类型

存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法。
Properties pros = new Properties();
pros.load(new FileInputStream("jdbc.properties"));
String user = pros.getProperty("user");
System.out.println(user);

Map接口及其实现类

1. Map接口介绍

2. Map接口中常用方法

元素的添加 、 删除、修改操作

元素查询的操作

遍历Map的三种方式☆

3. Map接口的实现类

3.1 HashMap集合

HashMap源码中的重要常量☆

HashMap的储存结构☆☆

JDK7

JDK8

小结

HashMap存储自定义类型键值

Student.java

测试类HashMapTest

LinkedHashMap集合☆

LinkedHashMap的静态内部类Entry

3.2 TreeMap集合

3.3 HashTable集合

Properties类

☆

元素的添加、删除、修改操作