哈希映射的工作原理是哈希

HashMap get(Key k) method calls hashCode method on the key object and applies returned hashValue to its own static hash function to find a bucket location(backing array) where keys and values are stored in form of a nested class called Entry (Map.Entry) . So you have concluded that from the previous line that Both key and value is stored in the bucket as a form of Entry object . So thinking that Only value is stored in the bucket is not correct and will not give a good impression on the interviewer .

每当我们调用HashMap对象上的get(Key k)方法时。首先，它检查key是否为空。注意，HashMap中只能有一个空键。

如果key为null，则null键总是映射到哈希0，因此索引为0。

如果key不为空，那么它将在key对象上调用hashfunction，参见上述方法中的第4行，即key. hashcode()，因此在key. hashcode()返回hashValue之后，第4行如下所示

            int hash = hash(hashValue)

现在，它将返回的hashValue应用到自己的哈希函数中。

我们可能想知道为什么要再次使用hash(hashvalue)计算哈希值。答案是它可以防御低质量的哈希函数。

现在使用final hashvalue来查找存储Entry对象的bucket位置。条目对象像这样存储在桶中(哈希，键，值，bucketindex)

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. 

hashcode决定要检查hashmap的哪个bucket。如果存储桶中有多个对象，则执行线性搜索以查找存储桶中的哪个项目等于所需的项目(使用equals()方法)。

In other words, if you have a perfect hashcode then hashmap access is constant, you will never have to iterate through a bucket (technically you would also have to have MAX_INT buckets, the Java implementation may share a few hash codes in the same bucket to cut down on space requirements). If you have the worst hashcode (always returns the same number) then your hashmap access becomes linear since you have to search through every item in the map (they're all in the same bucket) to get what you want.

大多数情况下，编写良好的hashcode并不完美，但它足够独特，可以为您提供或多或少的恒定访问。

哈希映射的工作原理是哈希

HashMap get(Key k) method calls hashCode method on the key object and applies returned hashValue to its own static hash function to find a bucket location(backing array) where keys and values are stored in form of a nested class called Entry (Map.Entry) . So you have concluded that from the previous line that Both key and value is stored in the bucket as a form of Entry object . So thinking that Only value is stored in the bucket is not correct and will not give a good impression on the interviewer .

每当我们调用HashMap对象上的get(Key k)方法时。首先，它检查key是否为空。注意，HashMap中只能有一个空键。

如果key为null，则null键总是映射到哈希0，因此索引为0。

如果key不为空，那么它将在key对象上调用hashfunction，参见上述方法中的第4行，即key. hashcode()，因此在key. hashcode()返回hashValue之后，第4行如下所示

            int hash = hash(hashValue)

现在，它将返回的hashValue应用到自己的哈希函数中。

我们可能想知道为什么要再次使用hash(hashvalue)计算哈希值。答案是它可以防御低质量的哈希函数。

现在使用final hashvalue来查找存储Entry对象的bucket位置。条目对象像这样存储在桶中(哈希，键，值，bucketindex)

两个对象相等，意味着它们具有相同的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。在此之后，链表转换为以第一个元素为根的平衡树(红黑树)。

每个Entry对象表示键值对。如果一个桶有多于1个Entry，则字段next指向其他Entry对象。

有时候，两个不同对象的hashcode可能是相同的。在这种情况下，2个对象将保存在一个桶中，并将显示为LinkedList。入口点是最近添加的对象。该对象引用具有next字段的其他对象，等等。最后一项为空。 当您使用默认构造函数创建HashMap时

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

(源)