7. Map接口及其实现类

Map接口及其实现类

1. Map接口介绍

1. 现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即 java.util.Map 接口。
2. Map与Collection并列存在。用于保存具有映射关系的数据:key-value。
3. Map 中的 key 和 value 都可以是任何引用类型的数据
4. Map 中的 key 用Set来存放， 不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法
   • 常用String类作为Map的“键”。
   • 
5. key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value。
6. Map接口中的集合都有两个泛型变量,在使用时，要为两个泛型变量赋予数据类型。两个泛型变量的数据类型可以相同，也可以不同。
7. Map接口的常用实现类：HashMap、TreeMap、LinkedHashMap和Properties。其中HashMap是 Map 接口使用频率最高的实现类

2. Map接口中常用方法

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

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

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

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

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

2.2 元素查询的操作

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

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

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

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

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

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

2.3 遍历Map的三种方式☆

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

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

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

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

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

public Set> 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集合

1. HashMap是 Map 接口 使用频率最高的实现类。
2. 允许使用null键和null值，与HashSet一样，不保证映射的顺序。
3. 所有的key构成的集合是Set:无序的、不可重复的。所以，key所在的类要重写：equals()和hashCode()。
4. 所有的value构成的集合是Collection:无序的、可以重复的。所以，value所在的类要重写：equals()。
5. 一个key-value构成一个entry
6. 所有的entry构成的集合是Set:无序的、不可重复的
7. HashMap 判断两个 key 相等的标准是：两个 key 通过 equals() 方法返回 true，hashCode 值也相等。
   • 因为key不允许有重复。
8. HashMap 判断两个 value 相等的标准是：两个 value 通过 equals() 方法返回 true。

HashMap源码中的重要常量☆

1. DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16

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

3. DEFAULT_LOAD_FACTOR ：HashMap的默认加载因子0.75

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

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

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

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

8. entrySet： 存储具体元素的集

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

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

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

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

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

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

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

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

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

HashMap的储存结构☆☆

1. JDK 7及以前版本：HashMap是数组+链表结构(即为链地址法)。
2. JDK 8版本发布以后：HashMap是数组+链表+红黑树实现。

JDK7

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

2. 每个bucket中存储一个元素，即一个Entry对象，但每一个Entry对象可以带一个引用变量，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Entry链。而且新添加的元素作为链表的head。

3. HashMap静态内部类Entry

    static class Entry<K,V> implements Map.Entry<K,V> {
           final K key;
           V value;
           final int hash;
           Entry<K,V> next;
        	// ....
    }
   

4. 添加元素的过程：

   1. 向HashMap中添加entry1(key，value)，需要首先计算entry1中key的哈希值(根据key所在类的hashCode()计算得到)，此哈希值经过处理以后，得到在底层Entry[]数组中要存储的位置i。
   2. 如果位置i上没有元素，则entry1直接添加成功。如果位置i上已经存在entry2(或还有链表存在的entry3，entry4)，则需要通过循环的方法，依次比较entry1中key和其他的entry。如果彼此hash值不同，则直接添加成功。
   3. 如果hash值不同，继续比较二者是否equals。如果返回值为true，则使用entry1的value
      去替换equals为true的entry的value。
   4. 如果遍历一遍以后，发现所有的equals返回都为false,则entry1仍可添加成功。entry1指向原有的entry元素。

5. HashMap 的扩容：

   1. 当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。
   2. 那么HashMap 什么时候进行扩容呢 ？
      1. 当HashMap中的元素个数超过数组大小(数组总大小length,不是数组中个数size)loadFactor 时 ， 就 会 进 行 数 组 扩 容 ， loadFactor 的 默 认 值(DEFAULT_LOAD_FACTOR)为0.75，这是一个折中的取值。
      2. 也就是说，默认情况下，数组大小(DEFAULT_INITIAL_CAPACITY)为16，那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

JDK8

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

2. 每个bucket中存储一个元素，即一个Node对象，但每一个Node对象可以带一个引用变量next，用于指向下一个元素，因此，在一个桶中，就有可能生成一个Node链。也可能是一个一个TreeNode对象，每一个TreeNode对象可以有两个叶子结点left和right，因此，在一个桶中，就有可能生成一个TreeNode树。而新添加的元素作为链表的last，或树的叶子结点。

3. HashMap的静态内部类Node

       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;
           }
       }
   

4. 那么HashMap 什么时候进行扩容和树形化呢 ？

   1. 当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的性能。
   2. 当HashMap中的其中一个链的对象个数如果达到了8个，此时如果capacity没有达到64，那么HashMap会先扩容解决，如果已经达到了64，那么这个链会变成树，结点类型由Node变成TreeNode类型。当然，如果当映射关系被移除后，下次resize方法时判断树的结点个数低于6个，也会把树再转为链表。
      • 如果不理解这段，可以看一下HashMap源码中的重要常量MIN_TREEIFY_CAPACITY。

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

   • 答案是：不要修改！

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

小结

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

1. HashMap map = new HashMap();//默认情况下，先不创建长度为16的数组。
2. 当首次调用map.put()时，再创建长度为16的数组。
3. 数组为Node类型，在jdk7中称为Entry类型。
4. 形成链表结构时，新添加的key-value对在链表的尾部（七上八下）。
5. 当数组指定索引位置的链表长度>8时，且map中的数组的长度> 64时，此索引位置上的所有key-value对使用红黑树进行存储。

HashMap存储自定义类型键值

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

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);
        }
    }
}

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

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

LinkedHashMap集合☆

1. 我们知道HashMap保证成对元素唯一，并且查询速度很快，可是成对元素存放进去是没有顺序的，那么我们要保证有序，还要速度快怎么办呢？
2. 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());
        }
    }
}

结果：

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

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集合

1. TreeMap存储 Key-Value 对时，需要根据 key-value 对进行排序。TreeMap 可以保证所有的 Key-Value 对处于有序状态。
2. TreeSet底层使用 红黑树 结构存储数据。
3. TreeMap 的 Key 的排序：
   • 自然排序：TreeMap 的所有的 Key 必须实现 Comparable 接口，而且所有的 Key 应该是同一个类的对象，否则将会抛出 ClasssCastException。
   • 定制排序：创建 TreeMap 时，传入一个 Comparator 对象，该对象负责对TreeMap 中的所有 key 进行排序。此时不需要 Map 的 Key 实现Comparable 接口
4. TreeMap判断两个key 相等的标准：两个key通过compareTo()方法或者compare()方法返回0。

3.3 HashTable集合

1. HashTable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap，Hashtable是线程安全的。
2. Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询速度快，很多情况下可以互用。
3. 与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value
4. 与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序
5. Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。

Properties类

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

2. 存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法。

3. Properties pros = new Properties();
   pros.load(new FileInputStream("jdbc.properties"));
   String user = pros.getProperty("user");
   System.out.println(user);
   

☆