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是一个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

下面是针对Java 8版本的HashMap机制的粗略描述(它可能与Java 6略有不同)。

数据结构

哈希表 哈希值通过key上的Hash()计算，它决定对给定的键使用哈希表的哪个桶。 链表(单个) 当桶中的元素数量较小时，使用单链表。 红黑树 当一个桶中的元素数量很大时，使用红黑树。

类(内部)

地图。条目 在map中表示单个实体，即键/值实体。 HashMap。节点 节点的链表版本。 它可以表示: 哈希桶。 因为它有哈希属性。 单链表中的节点(因此也是链表的头)。 HashMap。TreeNode 节点的树版本。

字段(内部)

节点[]表 桶表(链表的头)。 如果一个bucket不包含元素，那么它就是null，因此只占用一个引用的空间。 设置<地图。入口> entrySet 实体的集合。 int大小 实体数量。 负载系数浮动 在调整大小之前，指示允许的哈希表有多满。 int阈值 下一个要调整大小的大小。 公式:阈值=容量* loadFactor

方法(内部)

int散列(关键) 按键计算哈希值。 如何映射哈希到桶? 使用以下逻辑: static int hashToBucket(int tableSize, int hash) { return (tableSize - 1) & hash; ｝

关于能力

在哈希表中，容量是指桶数，可以从table.length中获取。 Also可以通过threshold和loadFactor计算，因此不需要定义为类字段。

可以通过:capacity()得到有效容量

操作

按键查找实体。 首先通过哈希值找到桶，然后循环链表或搜索排序树。 用键添加实体。 首先根据key的哈希值找到桶。 然后试着找出它的值: 如果找到，则替换该值。 否则，在链表的开头添加一个新节点，或插入到排序树中。 调整 当达到阈值时，将哈希表的容量(table.length)翻倍，然后对所有元素重新哈希以重建表。 这可能是一次昂贵的手术。

性能

获取并放置 时间复杂度为O(1)，因为: 桶通过数组索引访问，因此是O(1)。 每个桶中的链表长度较小，可见为O(1)。 树的大小也是有限的，因为当元素数量增加时将扩展容量并重新哈希，所以可以将其视为O(1)，而不是O(log N)。

我不会详细介绍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为该值找到一个合适的社会，然后存储该值。

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

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并不完美，但它足够独特，可以为您提供或多或少的恒定访问。

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.