两个对象相等，意味着它们具有相同的hashcode，而不是相反。 2个相等的对象------>他们有相同的hashcode 2个对象具有相同的hashcode ----xxxxx—>，它们不相等

HashMap中的Java 8更新

在代码中执行这个操作

myHashmap.put("old","old-value");
myHashMap.put("very-old","very-old-value");

所以，假设你的hashcode为“old”和“very old”两个键返回的hashcode是相同的。然后会发生什么。

myHashMap是一个HashMap，假设最初您没有指定它的容量。所以每个java的默认容量是16。所以现在只要你使用new关键字初始化hashmap，它就创建了16个桶。现在当你执行第一个语句

myHashmap.put("old","old-value");

然后计算“old”的hashcode，因为hashcode也可以是非常大的整数，所以，Java内部做了这个(hash是hashcode， >>>是右移)

hash XOR hash >>> 16

为了给出一个更大的图，它会返回一个索引值，在0到15之间。现在，键值对“old”和“old-value”将被转换为Entry对象的键值实例变量。然后这个entry对象会被存储在bucket中，或者你可以说在一个特定的索引处，这个entry对象会被存储。

入口是Map接口- Map中的一个类。条目，带有这些签名/定义

class Entry{
          final Key k;
          value v;
          final int hash;
          Entry next;
}

现在当你执行下一条语句时

myHashmap.put("very-old","very-old-value");

“very old”给出了与“old”相同的哈希码，所以这个新的键值对再次被发送到相同的索引或相同的存储桶。但是因为这个存储桶不是空的，所以Entry对象的下一个变量被用来存储这个新的键值对。

并且它将存储为每个具有相同hashcode的对象的链表，但TRIEFY_THRESHOLD的值为6。在此之后，链表转换为以第一个元素为根的平衡树(红黑树)。

import java.util.HashMap;

public class Students  {
    String name;
    int age;

    Students(String name, int age ){
        this.name = name;
        this.age=age;
    }

    @Override
    public int hashCode() {
        System.out.println("__hash__");
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        System.out.println("__eq__");
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Students other = (Students) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    public static void main(String[] args) {

        Students S1 = new Students("taj",22);
        Students S2 = new Students("taj",21);

        System.out.println(S1.hashCode());
        System.out.println(S2.hashCode());

        HashMap<Students,String > HM = new HashMap<Students,String > (); 
        HM.put(S1, "tajinder");
        HM.put(S2, "tajinder");
        System.out.println(HM.size());
    }
}

Output:

__ hash __

116232

__ hash __

116201

__ hash __

__ hash __

2

因此，在这里我们可以看到，如果对象S1和S2都有不同的内容，那么我们可以非常确定，我们覆盖的Hashcode方法将为两个对象生成不同的Hashcode(116232,11601)。因为有不同的哈希码，所以它甚至不需要调用EQUALS方法。因为不同的Hashcode保证对象中不同的内容。

    public static void main(String[] args) {

        Students S1 = new Students("taj",21);
        Students S2 = new Students("taj",21);

        System.out.println(S1.hashCode());
        System.out.println(S2.hashCode());

        HashMap<Students,String > HM = new HashMap<Students,String > (); 
        HM.put(S1, "tajinder");
        HM.put(S2, "tajinder");
        System.out.println(HM.size());
    }
}

Now lets change out main method a little bit. Output after this change is 

__ hash __

116201

__ hash __

116201

__ hash __

__ hash __

__ eq __

1
We can clearly see that equal method is called. Here is print statement __eq__, since we have same hashcode, then content of objects MAY or MAY not be similar. So program internally  calls Equal method to verify this. 


Conclusion 
If hashcode is different , equal method will not get called. 
if hashcode is same, equal method will get called.

Thanks , hope it helps. 

HashMap是一个Entry对象数组。

把HashMap看作是一个对象数组。

看看这个对象是什么:

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

每个Entry对象表示一个键值对。如果一个桶有多个Entry，下一个字段引用另一个Entry对象。

有时候，两个不同对象的哈希码可能是相同的。在这种情况下，两个对象将保存在一个bucket中，并将显示为链表。 入口点是最近添加的对象。该对象引用具有下一个字段的另一个对象，以此类推。最后一项指向null。

当使用默认构造函数创建HashMap时

HashMap hashMap = new HashMap();

数组的大小为16，默认负载平衡为0.75。

添加新的键-值对

计算键的hashcode 计算元素应该放置的位置哈希% (arrayLength-1)(桶号) 如果你试图用一个已经保存在HashMap中的键添加一个值，那么值将被覆盖。 否则元素被添加到桶中。

如果存储桶已经有至少一个元素，则添加一个新元素并将其放置在存储桶的第一个位置。它的下一个字段指向旧元素。

删除

计算给定键的hashcode 计算桶号哈希% (arrayLength-1) 获取桶中第一个Entry对象的引用，并通过equals方法遍历给定桶中的所有条目。最终我们会找到正确的入口。 如果没有找到所需的元素，则返回null

记住这里对hashmap结构的解释，也许有人可以解释Baeldung上的以下段落:-

Java有接口Map的几个实现，每个实现都有自己的特殊性。

但是，现有的Java核心Map实现都不允许Map处理单个键的多个值。

正如我们所看到的，如果我们试图为同一个键插入两个值，第二个值将被存储，而第一个值将被删除。

它还将返回(由put(K键，V值)方法的每个正确实现):

Map<String, String> map = new HashMap<>();
assertThat(map.put("key1", "value1")).isEqualTo(null);
assertThat(map.put("key1", "value2")).isEqualTo("value1");
assertThat(map.get("key1")).isEqualTo("value2");

你可以在http://javarevisited.blogspot.com/2011/02/how-hashmap-works-in-java.html上找到很好的信息

总结:

HashMap的工作原理是哈希

put(key, value): HashMap将key和value对象都存储为Map.Entry。Hashmap应用hashcode(key)来获取桶。如果有碰撞，HashMap使用LinkedList存储对象。

get(key): HashMap使用key Object的hashcode来查找桶的位置，然后调用keys.equals()方法来识别LinkedList中的正确节点，并在Java HashMap中返回该键的相关值对象。

我不会详细介绍HashMap是如何工作的，但是会给出一个例子，这样我们就可以通过将HashMap与现实联系起来来记住它是如何工作的。

我们有Key, Value,HashCode和bucket。

在一段时间内，我们将把它们与以下内容联系起来:

一个社会 HashCode ->社会地址(总是唯一的) 社会中的房子 Key ->房屋地址。

使用Map.get(key):

Stevie想去他的朋友(Josse)的房子，他住在一个VIP社会的别墅里，让它成为javalavers社会。 Josse的地址是他的SSN(每个人都不一样)。 有一个索引，我们可以根据社会安全号找到协会的名字。 这个索引可以被认为是一个找出HashCode的算法。

SSN协会名称 92313(Josse’s) -爪哇 13214—AngularJSLovers 98080—javalover 53808 -生物爱好者

这个SSN(密钥)首先给我们一个HashCode(来自索引表)，它只是社会的名字。 现在，多个房子可以在同一个社会中，所以HashCode可以是公共的。 假设，社会对两个房子都是公用的，我们如何识别我们要去哪个房子，是的，通过使用(SSN)密钥，它只是房子的地址

使用Map.put(关键字,值)

这将通过查找HashCode为该值找到一个合适的社会，然后存储该值。

我希望这能有所帮助，而且这是可以修改的。