转载

HashMap

参考：

Set 家族

Map 家族

Map 是一个键值对 (Key - Value pairs)，其中 key 是不可以重复

HashMap

那么与 Set 相对应的，Map 也有这三个实现类：

HashMap: 与 HashSet 对应，也是无序的，O(1)。

LinkedHashMap: 这是一个「HashMap + 双向链表」的结构，落脚点是 HashMap，所以既拥有 HashMap 的所有特性还能有顺序。

TreeMap: 是有序的，本质是用二叉搜索树来实现的。

HashMap 实现原理

对于 HashMap 中的每个 key，首先通过 hash function【哈希函数/散列函数】计算出一个 hash 值，这个hash值就代表了在 buckets 里的编号，而 buckets 实际上是用数组来实现的，所以把这个数值模上数组的长度得到它在数组的 index，就这样把它放在了数组里。

HashMap

问题1：如果不同的元素算出了相同的哈希值，那么该怎么存放呢？

答：这就是 哈希碰撞【冲突】 ，即多个 key 对应了同一个桶。

问题2：HashMap 中是如何保证元素的唯一性的呢？即相同的元素会不会算出不同的哈希值呢？

答：通过 hashCode() 和 equals() 方法来保证元素的唯一性。

问题3：如果 pairs 【碰撞】太多，buckets 太少怎么破？

答： Rehasing . 也就是碰撞太多的时候，会把数组扩容至两倍（默认）。所以这样虽然 hash 值没有变，但是因为数组的长度变了，所以算出来的 index 就变了，就会被分配到不同的位置上了，就不用挤在一起了。

问题4：那什么时候会 rehashing 【碰撞】呢？也就是怎么衡量桶里是不是足够拥挤要扩容了呢？

答： load factor 【装填因子】即用 pair 的数量除以 buckets 的数量，也就是 平均每个桶里装几对 。Java 中默认值是 0.75f ，如果超过了这个值就会 rehashing .

关于 hashCode() 和 equals()

如果 key 的 hashCode() 值相同，那么有可能是要发生 hash collision 了，也有可能是真的遇到了另一个自己。那么如何判断呢？继续用 equals() 来比较。

也就是说，

hashCode() 决定了 key 放在这个桶里的编号，也就是在数组里的 index；

HashMap

equals() 是用来比较两个 object 是否相同的。

HashMap

问题：为什么重写 equals() 方法时，一定要重写 hashCode() 呢？

参考： 1

答：是为了提高效率，采取重写hashcode方法，先进行hashcode比较，如果不同，那么就没必要在进行equals的比较了，这样就大大减少了equals比较的次数

例如：

我们都知道java中的List集合是有序的，因此是可以重复的，而set集合是无序的，因此是不能重复的，那么怎么能保证不能被放入重复的元素呢，但靠equals方法一样比较的话，如果原来集合中有10000个元素了，那么放入第10001个元素，难道要将前面的所有元素都进行比较，看看是否有重复，这个效率可想而知，因此hashcode就应遇而生了，java就采用了 hash表，利用哈希算法（也叫散列算法），就是将对象数据根据该对象的特征使用特定的算法将其定义到一个地址上，那么在后面定义进来的数据只要看对应的hashcode地址上是否有值，那么就用equals比较，如果没有则直接插入，只要就大大减少了equals的使用次数，执行效率就大大提高了。

同时也是为了保证同一个对象，保证在equals相同的情况下hashcode值必定相同，如果重写了equals而未重写hashcode方法，可能就会出现两个没有关系的对象equals相同的（因为equal都是根据对象的特征进行重写的），但hashcode确实不相同的。

添加元素会有重复性校验：

先取hashCode判断是否相等（找到对应的位置，该位置可能存在多个元素），然后再取equals方法比较（极大缩小比较范围，高效判断），最终判定该存储结构中是否有重复元素。

总结：

1.使用hashcode方法提前校验，可以避免每一次比对都调用equals方法，提高效率

2.保证是同一个对象，如果重写了equals方法，而没有重写hashcode方法，会出现equals相等的对象，hashcode不相等的情况，重写hashcode方法就是为了避免这种情况的出现。

问题：== 和 equals() 的区别？

参考：1 2

答：

==:比较

. 基本数据类型比较的是值；

. 引用类型比较的是 地址值 。

equals(Object o):

1）不能比较基本数据类型，基本数据类型不是类类型；

2）a.比较引用类型时（该方法继承自Object，在object中比较的是地址值）等同于”==”；

Object类中的方法,所以,在每一个java类中,都会有这个方法,因为每一个java类都是直接或者间接的Object类的子类,会继承到这个方法。

b.如果自己所写的类中已经重写了equals方法 ,那么就安装用户自定义的方式来比较俩个对象是否相等,如果没有重写过equal方法,那么会调用父类(Object)中的equals方法进行比较,也就是比较地址值。

注：有的实现类中（JDK中），重写了equals方法，这时候比较内容（java.lang.String）在自定义类中，如果比较对象，自己可以重写equals方法定义比较规则。

注意:equals(Object o)方法只能是一个对象来调用,然后参数也是要传一个对象的。

简述String s=”“和” “，以及null的区别

答：

“”代表空字符串，会在堆区开辟空间。

“ ”代表一个还有空格字符的字符串。

null 代表空值，不会再堆区开辟空间。

哈希冲突详解

一般来说哈希冲突有两大类解决方式：

参考：王道-数据结构

1、拉链法（链接法，Separate chaining）

Java 中采用的是第一种 Separate chaining ，即在发生碰撞的那个桶后面再加一条“链”来存储，那么这个“链”使用的具体是什么数据结构，不同的版本稍有不同：

在 JDK1.6 和 1.7 中，是用链表存储的，这样如果碰撞很多的话，就变成了在链表上的查找，worst case 就是 O(n)；

在 JDK 1.8 进行了优化，当链表长度较大时（超过 8），会采用 红黑树 来存储，这样大大提高了查找效率。

HashMap

2、开放定址法（Open addressing）

这种方法是顺序查找，如果这个桶里已经被占了，那就按照“ 某种方式 ”继续找下一个没有被占的桶，直到找到第一个空的。

HashMap

2.1 线性探测法（ `Linear probing` ）

如图所示，John Smith 和 Sandra Dee 发生了哈希冲突，都被计算到 152 号桶，于是 Sandra 就去了下一个空位 - 153 号桶，当然也会对之后的 key 发生影响：Ted Baker 计算结果本应是放在 153 号的，但鉴于已经被 Sandra 占了，就只能再去下一个空位了，所以到了 154 号。

这种方式叫做 线性探查 ，就像上图所示，一个个的顺着找下一个空位。

2.2平方探测法

2.3 再再散列法

2.4伪随机序列法

HashMap 基本操作

每种数据结构的基本操作都无外乎增删改查这四种，具体到 HashMap 来说，

增： put(K key, V value)
删： remove(Object key)
改：还是用的 put(K key, V value)
查： get(Object key) / containsKey(Object key)

举例：查看源码

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    /**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }