Map的使用

　　map是一种依照键/值对存储元素的容器。它提供了通过键快速获取、删除和更新键/值对的功能。map将键值一起保存。键很像下标，在list中，下标是整数；而在map中，键可以是任意类型的对象。map中不能有重复的键，每个键都对应一个值。一个键和它对应值构成一个条目并保存在map中，如下图所示。

　　map的类型有三种：散列映射表HashMap、链式散列映射表LinkedHashMap和树形映射表TreeMap。这些映射表的通用特性都定义在Map接口中，他们的关系及具体实现如下图所示。

　　map接口提供了查询、更新和获取条目的值和条目的键的方法。对于定位一个值、插入一个条目以及删除一个条目而言，HashMap类是高效的。

　　LinkedHashMap类用链表实现来扩展HashMap类，它支持map中条目的排序.HashMap类中的条目是没有顺序的，但是在LinkedHashMap中，元素既可以按照他们插入map的顺序排序（插入顺序（insertion order）），也可以按它们被最后一次访问时的顺序，从最早到最晚（访问顺序（access order））。无参构造方法是以插入顺序来创建LinkedHashMap的。要按照访问顺序创建LinkedHashMap应该使用构造方法LinkedHashMap(initialCapacity,loadFactor,true).

　　TreeMap类在遍历排好顺序的键时是非常高效的。键可以使用Comparable接口或者Comparator接口来排序。

　　SortedMap是Map的一个子接口，使用它可确保map中的条目是排好序的。除此之外，它还提供firstKey()和lastKey()来返回map中的第一个和最后一个键，而方法headMap(toKey)和tailMap(fromKey)分别返回key小于toKey的那部分map和key大于formKey的那部分map。

示例：统计一篇文章每个单词出现的次数

public class HashMapDemo {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        try (BufferedReader reader = new BufferedReader(new FileReader("D:/test/test.txt"))){
            
            //循环读取每一行
            String line = null;
            while((line = reader.readLine()) != null) {
                String[] words = line.split("[^a-zA-Z]+");
                for(String src : words) {
                    if(map.containsKey(src)) {//表示map中已经存在key为当店迭代的单词，需要对该key对应的value+1
                        int count = map.get(src);
                        map.replace(src, count + 1);
                    }else
                        map.put(src, 1);
                }
            }
            //1.如果map中存储该单词，就对该单词次数进行+1，else 就将该单词存放进map中
        } catch (IOException e) {
            e.printStackTrace();
        }
        /**
         * 遍历Map：
         *     1.可以获取所有的key=====>keySet
         * 2.可以获取所有的values====>values
         * 3.遍历所有的条目
         * 4.JDK8增强：forEach
         */
//        Set<String> keys = map.keySet();
//        for(String key : keys)
//            map.get(key);
        
        //map.values();
        Set<Entry<String, Integer>> entries = map.entrySet();
        for(Entry<String, Integer> entry : entries) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
        //jdk 8增强
        //map.forEach((key,value)->System.out.println(key + ":" + value));
    }
}

HashMap原理概述

　　HashMap底层实现采用了散列表,这是一种非常重要的数据结构。对于我们以后理解很多技术都非常有帮助(比如: redis数据库的核心技术和HashMap-样) ,因此,非常有必要让大家理解。

　　数据结构中由数组和链表来实现对数据的存储,他们各有特点。

　　(1)数组:占用空间连续。寻址容易 ,查询速度快。但是,增加和删除效率非常低

　　(2)链表:占用空间不连续。寻址困难 ,查询速度慢。但是,增加和删除效率非常高。

　　那么,我们能不能结合数组和链表的优点(即查询快,增删效率也高)呢?答案就是"哈希表”。哈希表的本质就是“数组+链表"。

查看源码

public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
　　/**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    /**
     * The maximum capacity, used if a higher value is implicitly specified
     * by either of the constructors with arguments.
     * MUST be a power of two <= 1<<30.
     */
    static final int MAXIMUM_CAPACITY = 1 << 30;
    /**
     * The load factor used when none specified in constructor.
     */
　　static final float DEFAULT_LOAD_FACTOR = 0.75f;
　　/**
     * The table, initialized on first use, and resized as
     * necessary. When allocated, length is always a power of two.
     * (We also tolerate length zero in some operations to allow
     * bootstrapping mechanics that are currently not needed.)
　　　*/
　　transient Node<K,V>[] table;
 ...
}

　　其中的Node[ ]table就是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;
        }
}

　　一个Node对象存储了：

　　1. key :键对象value :值对象

　　2. next:下一个节点

　　3. hash:键对象的hash值

　　显然每一个Entry对象就是一个单向链表结构,我们使用图形表示一个Entry对象的典型示意 :

　　　　　　　　　　　　　　　　　　　　　　　　Node对象存储结构图

然后,我们画出Node[]数组的结构(这也是HashMap的结构) :

l 存储数据过程put(key,value)

　　明白了HashMap的基本结构后,我们继续深入学习HashMap如何存储数据。此处的核心是如何产生hash值,该值用来对应数组的存储位置。

我们的目的是将”key-value两个对象”成对存放到HashMap的Node[]数组中。参见以下步骤:

获得key对象的hashcode

　　　　首先调用key对象的hashcode0方法,获得hashcode.

　　 2.根据hashcode计算出hash值(要求在[0,数组长度 - 1]区间)

　　　　hashcode是一个整数,我们需要将它转化成[0,数组长度- 1]的范围。我们要求转化后的hash值尽量均匀地分布在[0,数组长度- 1]这个区间,减少"hash冲突".一种简单和常用的算法是(相除取余算法) :hash值= hashcode%数组长度。这种算法可以让hash值均匀的分布在[0,数组长度- 1]的区间。早期的HashTable就是采用这种算法。但是,这种算法由于使用了"除法”, 效率低下。JDK后来改进了算法。首先约定数组长度必须为2的整数幂,这样采用位运算即可实现取余的效果: hash值= hashcode&(数组长度-1)。为了获得更好的散列效果。JDK对hashcode进行了两次散列处理(核心目标就是为了分布更散更均匀),源码如下:

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

　　 3.生成Node对象

　　　　如上所述, 一个Node对象包含4部分: key对象、value对象、 hash值、指向下一个Node对象的引用。我们现在算出了hash值。下一个Node对象的引用为null。

　　 4.将Node对象放到table数组中

　　　　如果本Node对象对应的数组索弓|位置还没有放Node对象,则直接将NodeNode存储进数组;如果对应索引位置已经有Node对象,则将已有Node对象的next指向本Entry对象,形成链表。

　　总结如上过程:当添加一个元素(key-value)时 ,首先计算key的hash值,以此确定插入数组中的位置,但是可能存在同一hash值的元素已经被放在数组同一位置了,这时就添加到同一hash值的元素的后面,他们在数组的同一位置,就形成了链表,同一个链表上的Hash值是相同的,所以说数组存放的是链表。

　　JDK8中,当链表长度大于8时,链表就转换为红黑树,这样又大大提高了查找的效率。

Ⅱ 取数据过程get(key)

　　我们需要通过key对象获得“键值对”对象,进而返回value对象。明白了存储数据过程,取数据就比较简单了,参见以下步骤:

获得key的hashcode ,通过hash()散列算法得到hash值,进而定位到数组的位置。
在链表上挨个比较key对象。调用equals()方法 ,将key对象和链表上所有节点的key对象进行比较,直到碰到返回true的节点对象为止。
返回equals()为true的节点对象的value对象。

　　明白了存取数据的过程,我们再来看一下hashcode()和equals方法的关系 :

　　Java中规定,两个内容相同(equals()为true)的对象必须具有相等的hashCode。因为如果equals()为true而两个对象的hashcode不同;那在整个存储过程中就发生了悖论。

Ⅲ 扩容问题

　　HashMap的位桶数组,初始大小为16。实际使用时,显然大小是可变的。如果位桶数组中的元素达到(0.75*数组length)，就重新调整数组大小变为原来2倍大小。扩容很耗时。扩容的本质是定义新的更大的数组,并将旧数组内容挨个拷贝到新数组中。JDK8中, HashMap在存储一个元素时,当对应链表长度大于8时,链表就转换为红黑树,这样又大大提高了查找的效率。