HashMap

HashMap

基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 此实现假定哈希函数将元素适当地分布在各桶之间，可为基本操作（get 和 put）提供稳定的性能。迭代 collection 视图所需的时间与 HashMap 实例的“容量”（桶的数量）及其大小（键-值映射关系数）成比例。所以，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。

HashMap是基于哈希表的Map接口的非同步实现，此实现提供所有可选的映射操作，并允许使用null值和null键。它不保证映射的顺序，HashMap是Hashtable的轻量级实现（非线程安全的实现），它们都完成了Map接口。

哈希表（Hash table，也叫散列表），是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。
给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。

HashMap： 实现一个映象，允许存储空对象，而且允许键是空（由于键必须是唯一的，当然只能有一个）。

HashMap对象：实现集的存储和检索操作是在固定时间内实现的。（HashSet类集使用散列表进行存储，关键字的内容被生成唯一值，称散列码hashcode，散列码被用作与关键字相连的数据的存储下标。）

HashMap的数据结构

哈希表是由数组+链表组成的，（jdk1.8之前的）数组的默认长度为16。

为什么是数组+链表？

• 数组对于数据的访问如查找和读取非常方便，链表对于数据插入非常方便。
• 链表可以解决hash值冲突（即对于不同的key值可能会得到相同的hash值）
• 数组里每个元素存储的是一个链表的头结点。而组成链表的结点其实就是hashmap内部定义的一个类：Entity；Entity包含三个元素：key，value和指向下一个Entity的next。

HashMap的存取

HashMap的存储 put：null key总是存放在Entry[]数组的第一个元素。

元素需要存储在数组中的位置。先判断该位置上有没有存有Entity，没有的话就创建一个Entity<k,v>对象，新的Entity插入（put）的位置永远是在链表的最前面。

HashMap的读取 get：先定位到数组元素，再遍历该元素处的链表。

覆盖了equals方法之后一定要覆盖hashCode方法，原因很简单，比如，String a = new String(“abc”); String b = new String(“abc”); 如果不覆盖hashCode的话，那么a和b的hashCode就会不同。

HashMap是基于hashing的原理，使用put(key, value)存储对象到HashMap中，使用get(key)从HashMap中获取对象。当给put()方法传递键和值时，先对键调用hashCode()方法，返回的hashCode用于找到bucket位置来储存Entry对象。

什么是HaspMap和Map？

Map是接口，Java 集合框架中一部分，用于存储键值对，HashMap是用哈希算法实现Map的类。

HashMap与HashTable有什么区别？

两者都是用key-value方式获取数据。HashTable是原始集合类之一（也称作遗留类）。HashMap作为新集合框架的一部分在Java2的1.2版本中加入。它们之间有一下区别：

• HashMap和HashTable大致是等同的，除了非同步和空值（HashMap允许null值作为key和value，而HashTable不可以）。
• HashMap没法保证映射的顺序一直不变，但是作为HashMap的子类LinkedHashMap，如果想要预知的顺序迭代（默认按照插入顺序），你可以很轻易的置换为HashMap，如果使用Hashtable就没那么容易了。
• HashMap不是同步的，而HashTable是同步的。
• 迭代HashMap采用快速失败机制，而HashTable不是，所以这是设计的考虑点。

基本的不同点是：HashTable同步，HashMap不是同步的，所以无论什么时候有多个线程访问相同实例的可能时，就应该使用HashTable，反之使用HashMap。非线程安全的数据结构能带来更好的性能。

如果在将来有一种可能—你需要按顺序获得键值对的方案时，HashMap是一个很好的选择，因为有HashMap的一个子类 LinkedHashMap。所以如果你想可预测的按顺序迭代（默认按插入的顺序），你可以很方便用LinkedHashMap替换HashMap。反观要是使用的HashTable就没那么简单了。同时如果有多个线程访问HashMap，Collections.synchronizedMap()可以代替，总的来说HashMap更灵活。

• HashMap几乎可以等价于HashTable，除了HashMap是非Synchronized的，并可以接受null(HashMap可以接受为null的键值(key)和值(value)，而HashTable则不行)。
• HashMap是非Synchronized，而HashTable是Synchronized，这意味着HashTable是线程安全的，多个线程可以共享一个HashTtable；而如果没有正确的同步的话，多个线程是不能共享HashMap的。Java 5提供了ConcurrentHashMap，它是HashTable的替代，比HashTable的扩展性更好。另一个区别是HashMap的迭代器(Iterator)是fail-fast迭代器，而Hashtable的enumerator迭代器不是fail-fast的。所以当有其它线程改变了HashMap的结构（增加或者移除元素），将会抛出ConcurrentModificationException，但迭代器本身的remove()方法移除元素则不会抛出ConcurrentModificationException异常。这并不是一个一定发生的行为，要看JVM。这条同样也是Enumeration和Iterator的区别。
• 由于HashTable是线程安全的也是Synchronized，所以在单线程环境下它比HashMap要慢。如果不需要同步，只需要单一线程，那么使用HashMap性能要好过Hashtable。HashMap不能保证随着时间的推移Map中的元素次序是不变的。

sychronized意味着在一次仅有一个线程能够更改Hashtable。就是说任何线程要更新Hashtable时要首先获得同步锁，其它线程要等到同步锁被释放之后才能再次获得同步锁更新Hashtable。

Fail-safe和iterator迭代器相关。如果某个集合对象创建了Iterator或者ListIterator，然后其它的线程试图“结构上”更改集合对象，将会抛出ConcurrentModificationException异常。但其它线程可以通过set()方法更改集合对象是允许的，因为这并没有从“结构上”更改集合。但是假如已经从结构上进行了更改，再调用set()方法，将会抛出IllegalArgumentException异常。

结构上的更改指的是删除或者插入一个元素，这样会影响到map的结构。

（1）继承的父类不同
Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。

（2）线程安全性不同
Hashtable 中的方法是Synchronize的，而HashMap中的方法在缺省情况下是非Synchronize的。在多线程并发的环境下，可以直接使用Hashtable，不需要自己为它的方法实现同步，但使用HashMap时就必须要自己增加同步处理。

（3）是否提供contains方法
HashMap把Hashtable的contains方法去掉了，改成containsValue和containsKey，因为contains方法容易让人引起误解。
Hashtable则保留了contains，containsValue和containsKey三个方法，其中contains和containsValue功能相同。

（4）key和value是否允许null值
其中key和value都是对象，并且不能包含重复key，但可以包含重复的value。
Hashtable中，key和value都不允许出现null值。
HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，可能是 HashMap中没有该键，也可能使该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。

（5）两个遍历方式的内部实现上不同
Hashtable、HashMap都使用了 Iterator。而由于历史原因，Hashtable还使用了Enumeration的方式 。

（6）hash值不同
哈希值的使用不同，HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

（7）内部实现使用的数组初始化和扩容方式不同
Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11，增加的方式是 old*2+1。

HashMap中hash数组的默认大小是16，而且一定是2的指数。

在HashTable上下文中同步是什么意思？

同步意味着在一个时间点只能有一个线程可以修改哈希表，任何线程在执行hashtable的更新操作前需要获取对象锁，其他线程等待锁的释放。

怎样使HashMap同步？

首先，HashMap不支持线程的同步。同步，指的是在一个时间点只能有一个线程可以修改hash表，任何线程在执行HashTable的更新操作前都需要获取对象锁，其他线程则等待锁的释放。实现HashMap的同步的方法：
第一种方法：
直接使用HashTable，但是当一个线程访问HashTable的同步方法时，其他线程如果也要访问同步方法，会被阻塞住。举个例子，当一个线程使用put方法时，另一个线程不但不可以使用put方法，连get方法都不可以，效率很低，现在基本不会选择它了。

第二种方法：
HashMap可以通过此语句进行同步：Collections.synchronizeMap(hashMap);
HashMap可以通过Map m = Collections.synchronizedMap(new HashMap())来达到同步的效果。具体而言，该方法返回一个同步的Map，该Map封装了底层的HashMap的所有方法，使得底层的HashMap即使在多线程的环境中也是安全的。

第三种方法：
直接使用JDK 5 之后的 ConcurrentHashMap，如果使用Java 5或以上的话，请使用ConcurrentHashMap。

HashTable的put和get方法均为Synchronized的是线程安全的。

将HashMap默认划分为了16个Segment，减少了锁的争用。

写时加锁，读时不加锁减少了锁的持有时间。

volatile特性约束变量的值在本地线程副本中修改后会立即同步到主线程中，保证了其他线程的可见性。

value外，其他的属性都是final的，value是volatile类型的，都修饰为final表明不允许在此链表结构的中间或者尾部做添加删除操作，每次只允许操作链表的头部。

为什么HashMap是线程不安全的，实际会如何体现？

第一：如果多个线程同时使用put方法添加元素。假设正好存在两个put的key发生了碰撞(hash值一样)，那么根据HashMap的实现，这两个key会添加到数组的同一个位置，这样最终就会发生其中一个线程的put的数据被覆盖。

第二：如果多个线程同时检测到元素个数超过数组大小*loadFactor。这样会发生多个线程同时对hash数组进行扩容，都在重新计算元素位置以及复制数据，但是最终只有一个线程扩容后的数组会赋给table，也就是说其他线程的都会丢失，并且各自线程put的数据也丢失。且会引起死循环的错误。

HashMap底层是一个Entry数组，当发生hash冲突的时候，hashmap是采用链表的方式来解决的，在对应的数组位置存放链表的头结点。对链表而言，新加入的节点会从头结点加入。

HashMap 的 HashCode 的作用？什么时候需要重写？如何解决哈希冲突？查找的时候流程是如何？

当向集合中插入对象时，如何判别在集合中是否已经存在该对象了？（注意：集合中不允许重复的元素存在）也许大多数人都会想到调用equals方法来逐个进行比较，这个方法确实可行。但是如果集合中已经存在一万条数据或者更多的数据，如果采用equals方法去逐一比较，效率必然是一个问题。
此时HashCode方法的作用就体现出来了，当集合要添加新的对象时，先调用这个对象的HashCode方法，得到对应的HashCode值。实际上在HashMap的具体实现中会用一个table保存已经存进去的对象的HashCode值，如果table中没有该HashCode值，它就可以直接存进去，不用再进行任何比较了；如果存在该HashCode值， 就调用它的equals方法与新元素进行比较，相同的话就不存了，不相同就散列其它的地址，所以这里存在一个冲突解决的问题，这样一来实际调用equals方法的次数就大大降低了。

HashMap有一个叫做Entry的内部类，它用来存储key-value对。上面的Entry对象是存储在一个叫做table的Entry数组中。table的索引在逻辑上叫做“桶”(bucket)，它存储了链表的第一个元素。key的hashcode()方法用来找到Entry对象所在的桶。如果两个key有相同的hash值（即冲突），他们会被放在table数组的同一个桶里面（以链表方式存储）。key的equals()方法用来确保key的唯一性。key的value对象的equals()和hashcode()方法根本一点用也没有。

HashTable 概述

也是一个散列表，它存储的内容是键值对(key-value)映射。

• HashTable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口
• HashTable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。
• HashTable中的映射不是有序的。
• HashTable继承于Dictionary类，实现了Map接口。Map是"key-value键值对"接口，Dictionary是声明了操作"键值对"函数接口的抽象类。

Hashmap与Currenthashmap区别

Hashtable中采用的锁机制是一次锁住整个hash表，从而同一时刻只能由一个线程对其进行操作；而ConcurrentHashMap中则是一次锁住一个桶。ConcurrentHashMap默认将hash表分为16个段，诸如get,put,remove等常用操作只锁当前需要用到的桶。Hashtable是线程安全的，它的方法是同步了的，可以直接用在多线程环境中。而HashMap则不是线程安全的。在多线程环境中，需要手动实现同步机制。

Hashmap与Linkedhashmap区别

Linkedhashmap是hashmap子类多了after和behind方法。
LinkedHashMap比HashMap多维护了一个链表。

HashMap、LinkedHashMap、TreeMap、WeakHashMap

HashMap里面存入的键值对在取出时没有固定的顺序，是随机的。一般而言，在Map中插入、删除和定位元素，HashMap是最好的选择。

由于TreeMap实现了SortMap接口，能够把它保存的记录根据键排序，因此，取出来的是排序后的键值对，如果需要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。

LinkedHashMap是HashMap的一个子类，如果需要输出的顺序和输入相同，那么用LinkedHashMap可以实现、它还可以按读取顺序来排列。

WeakHashMap中key采用的是“弱引用”的方式，只要WeakHashMap中的key不再被外部引用，它就可以被垃圾回收器回收。
而HashMap中key采用的是“强引用的方式”，当HashMap中的key没有被外部引用时，只有在这个key从HashMap中删除后，才可以被垃圾回收器回收。

“你用过HashMap吗？” “什么是HashMap？你为什么用到它？”

几乎每个人都会回答“是的”，然后回答HashMap的一些特性，譬如HashMap可以接受null键值和值，而Hashtable则不能；HashMap是非synchronized;HashMap很快；以及HashMap储存的是键值对等等。这显示出你已经用过HashMap，而且对它相当的熟悉。但是面试官来个急转直下，从此刻开始问出一些刁钻的问题，关于HashMap的更多基础的细节。

你知道HashMap的工作原理吗？ 你知道HashMap的get()方法的工作原理吗？

“HashMap是基于hashing的原理，使用put(key,value)存储对象到HashMap中，使用get(key)从HashMap中获取对象（其实就是得到value，在java里嘛，万物皆对象）。当给put()方法传递键和值时，先对键调用hashCode()方法，返回的hashCode用于找到bucket位置来储存Entry对象。”这里关键点在于指出，HashMap是在bucket中储存键对象和值对象，作为Map.Entry。

当两个对象的hashcode相同会发生什么？

因为hashcode相同，所以它们的bucket位置相同，‘碰撞’会发生。因为HashMap使用链表存储对象，这个Entry(包含有键值对的Map.Entry对象)会存储在链表中。

如果两个key的hashcode相同，你如何获取值对象？

当调用get()方法，HashMap会使用键对象的hashcode找到bucket位置，找到bucket位置之后，会调用keys.equals()方法去找到链表中正确的节点，最终找到要找的值对象。
注意：面试官会问因为你并没有值对象去比较，你是如何确定确定找到值对象的？除非面试者直到HashMap在链表中存储的是键值对，否则他们不可能回答出这一题。一些优秀的开发者会指出使用不可变的、声明作final的对象，并且采用合适的equals()和hashCode()方法的话，将会减少碰撞的发生，提高效率。不可变性使得能够缓存不同键的hashcode，这将提高整个获取对象的速度，使用String，Interger这样的wrapper类作为键是非常好的选择。

Hashmap的存储过程？

HashMap内部维护了一个存储数据的Entry数组，HashMap采用链表解决冲突，每一个Entry本质上是一个单向链表。当准备添加一个key-value对时，首先通过hash(key)方法计算hash值，然后通过indexFor(hash,length)求该key-value对的存储位置，计算方法是先用hash&0x7FFFFFFF后，再对length取模，这就保证每一个key-value对都能存入HashMap中，当计算出的位置相同时，由于存入位置是一个链表，则把这个key-value对插入链表头。HashMap中key和value都允许为null。key为null的键值对永远都放在以table[0]为头结点的链表中。

HashMap扩容问题？

扩容是是新建了一个HashMap的底层数组，而后调用transfer方法，将HashMap的全部元素添加到新的HashMap中（要重新计算元素在新的数组中的索引位置）。 很明显，扩容是一个相当耗时的操作，因为它需要重新计算这些元素在新的数组中的位置并进行复制处理。因此，我们在用HashMap的时，最好能提前预估下HashMap中元素的个数，这样有助于提高HashMap的性能。

HashMap共有四个构造方法。构造方法中提到了两个很重要的参数：初始容量和加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中槽的数量（即哈希数组的长度），初始容量是创建哈希表时的容量（从构造函数中可以看出，如果不指明，则默认为16），加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，当哈希表中的条目数超出了加载因子与当前容量的乘积时，则要对该哈希表进行 resize 操作（即扩容）。

默认加载因子为0.75，如果加载因子越大，对空间的利用更充分，但是查找效率会降低（链表长度会越来越长）；如果加载因子太小，那么表中的数据将过于稀疏（很多空间还没用，就开始扩容了），对空间造成严重浪费。如果我们在构造方法中不指定，则系统默认加载因子为0.75，这是一个比较理想的值，一般情况下我们是无需修改的。

什么时候扩容：通过HashMap源码可以看到是在put操作时，即向容器中添加元素时，判断当前容器中元素的个数是否达到阈值（当前数组长度乘以加载因子的值）的时候，就要自动扩容了。

扩容(resize)：其实就是重新计算容量；而这个扩容是计算出所需容器的大小之后重新定义一个新的容器，将原来容器中的元素放入其中。

HashMap的复杂度

HashMap整体上性能都非常不错，但是不稳定，为O(N/Buckets)，N就是以数组中没有发生碰撞的元素。

HashMap的key必须惟一，value可重复

HashMap源码分析

1、构造函数

1.1 HashMap()

    // 1.无参构造方法、
    // 构造一个空的HashMap，初始容量为16，负载因子为0.75
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }

1.2 HashMap(int initialCapacity)

    // 2.构造一个初始容量为initialCapacity，负载因子为0.75的空的HashMap，
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

1.3 HashMap(int initialCapacity, float loadFactor)

    // 3.构造一个空的初始容量为initialCapacity，负载因子为loadFactor的HashMap
    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

    //最大容量
    //static final int MAXIMUM_CAPACITY = 1 << 30;

当指定的初始容量< 0时抛出IllegalArgumentException异常，当指定的初始容量> MAXIMUM_CAPACITY时，就让初始容量 = MAXIMUM_CAPACITY。当负载因子小于0或者不是数字时，抛出IllegalArgumentException异常。

设定threshold。 这个threshold = capacity * load factor 。当HashMap的size到了threshold时，就要进行resize，也就是扩容。

tableSizeFor()的主要功能是返回一个比给定整数大且最接近的2的幂次方整数，如给定10，返回2的4次方16.

1.4 HashMap(Map<? extends K, ? extends V> m)

    // 4. 构造一个和指定Map有相同mappings的HashMap，初始容量能充足的容下指定的Map,负载因子为0.75
    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

    /**
     * 将m的所有元素存入本HashMap实例中
     */
    final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
        //得到 m 中元素的个数
        int s = m.size();
        //当 m 中有元素时，则需将map中元素放入本HashMap实例。
        if (s > 0) {
            // 判断table是否已经初始化，如果未初始化，则先初始化一些变量。（table初始化是在put时）
            if (table == null) { // pre-size
                // 根据待插入的map 的 size 计算要创建的　HashMap 的容量。
                float ft = ((float)s / loadFactor) + 1.0F;
                int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                         (int)ft : MAXIMUM_CAPACITY);
                // 把要创建的　HashMap 的容量存在　threshold　中
                if (t > threshold)
                    threshold = tableSizeFor(t);
            }
            // 如果table初始化过，因为别的函数也会调用它，所以有可能HashMap已经被初始化过了。
            // 判断待插入的　map 的 size,若　size 大于　threshold，则先进行　resize()，进行扩容
            else if (s > threshold)
                resize();
            //然后就开始遍历 带插入的 map ，将每一个 <Key ,Value> 插入到本HashMap实例。
            for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
                K key = e.getKey();
                V value = e.getValue();
                // put(K,V)也是调用　putVal　函数进行元素的插入
                putVal(hash(key), key, value, false, evict);
            }
        }
    }