悲催，放到 Map 中的元素取不出来了

‍ 如果你只想看结论，给你上个一句话省流版：

public class Player {    private String name;
    public Player(String name) {        this.name = name;    }
    // 省略了getter和setter方法        @Override    public boolean equals(Object o) {        if (this == o) {            return true;        }        if (!(o instanceof Player)) {            return false;        }        Player player = (Player) o;        return name.equals(player.name);    }
    @Override    public int hashCode() {        return name.hashCode();    }}

此时，有懂行的小伙伴已经看出了一点端倪

Map myMap = new HashMap<>();Player kai = new Player("Kai");Player tom = new Player("Tom");Player amanda = new Player("Amanda");myMap.put(kai, 42);myMap.put(amanda, 88);myMap.put(tom, 200);assertTrue(myMap.containsKey(kai));

// 将Kai的名字更改为Erickai.setName("Eric");assertEquals("Eric", kai.getName());
Player eric = new Player("Eric");assertEquals(eric, kai);
// 现在，map中既不包含Kai也不包含Eric：assertFalse(myMap.containsKey(kai));assertFalse(myMap.containsKey(eric));
assertNull(myMap.get(kai));assertNull(myMap.get(eric));

// 然而 Player("Eric") 以依然存在：long ericCount = myMap.keySet().stream().filter(player -> player.getName()        .equals("Eric")).count();assertEquals(1, ericCount);

3.1.1 put 方法概述

/** * Associates the specified value with the specified key in this map. * If the map previously contained a mapping for the key, the old * value is replaced. * * @param key key with which the specified value is to be associated * @param value value to be associated with the specified key * @return the previous value associated with key, or *         null if there was no mapping for key. *         (A null return can also indicate that the map *         previously associated null with key.) */




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

3.1.2 hash 方法

    /**     * Computes key.hashCode() and spreads (XORs) higher bits of hash     * to lower.  Because the table uses power-of-two masking, sets of     * hashes that vary only in bits above the current mask will     * always collide. (Among known examples are sets of Float keys     * holding consecutive whole numbers in small tables.)  So we     * apply a transform that spreads the impact of higher bits     * downward. There is a tradeoff between speed, utility, and     * quality of bit-spreading. Because many common sets of hashes     * are already reasonably distributed (so don't benefit from     * spreading), and because we use trees to handle large sets of     * collisions in bins, we just XOR some shifted bits in the     * cheapest possible way to reduce systematic lossage, as well as     * to incorporate impact of the highest bits that would otherwise     * never be used in index calculations because of table bounds.     */    static final int hash(Object key) {        int h;        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);    }

3.1.3 putVal 方法

    /**     * 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) {        //定义了一个用于表示哈希表的数组 tab，一个节点 p 用于指向特定的哈希桶，        // 以及两个整型变量 n 和 i 用于存储哈希表的大小和计算的索引位置。        Node[] tab; Node p; int n, i;
        //如果哈希表未初始化或其长度为0，它将调用 resize() 方法来初始化或扩容哈希表。        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 e; K k;                        //检查第一个节点是否有相同的哈希和键。            if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))                e = p;                                //如果首个节点是一个红黑树节点，则调用 putTreeVal 方法来处理。            else if (p instanceof TreeNode)                e = ((TreeNode)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;                }            }                        //如果找到了一个存在的节点，则根据 onlyIfAbsent 参数来决定是否要更新值，然后返回旧值。            if (e != null) { // existing mapping for key                V oldValue = e.value;                if (!onlyIfAbsent || oldValue == null)                    e.value = value;                afterNodeAccess(e);                return oldValue;            }        }
        //增加 modCount 来表示 HashMap 被修改了，并检查当前大小是否超过了阈值来决定是否要调整大小        ++modCount;        if (++size > threshold)            resize();
        //最后调用 afterNodeInsertion 方法（它在 HashMap 中是一个空方法，但在其子类 LinkedHashMap 中是有定义的），        //然后返回 null 来表示没有旧值。        afterNodeInsertion(evict);        return null;    }

3.2.1 containsKey 概览

    /**     * Returns true if this map contains a mapping for the     * specified key.     *     * @param   key   The key whose presence in this map is to be tested     * @return true if this map contains a mapping for the specified     * key.     */    public




    
 boolean containsKey(Object key) {        return getNode(hash(key), key) != null;    }

3.2.2 hash 方法

3.2.3 getNode 方法

    /**     * Implements Map.get and related methods.     *     * @param hash hash for key     * @param key the key     * @return the node, or null if none     */    final Node getNode(int hash, Object key) {        //首先定义了一些变量，包括哈希表数组 tab、要查找的首个节点 first、        //一个辅助节点 e、数组的长度 n 和一个泛型类型的 k 用于暂存 key。        Node[] tab; Node first, e; int n; K k;                //这里首先检查哈希表是否为空或长度是否大于 0 ,然后根据 hash 值找到对应的桶。        //(n - 1) & hash 这段代码是为了将 hash 值限制在数组的边界内，确保它能找到一个有效的桶。        if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {
            //检查第一个节点是否就是我们要找的节点，这里比较了 hash 值和 key。            //注意这里首先通过 == 来比较引用，如果失败了再通过 equals 方法来比较值，这样可以提高效率。            if (first.hash == hash && // always check first node                ((k = first.key) == key || (key != null && key.equals(k))))                return first;                        // 如果第一个节点不是我们要找的，就检查下一个节点是否存在。            if ((e = first.next) != null) {                //如果首个节点是一个树节点（即这个桶已经转换为红黑树结构），则调用 getTreeNode 方法来获取节点。                if (first instanceof TreeNode)                    return ((TreeNode)first).getTreeNode(hash, key);                                //这是一个 do-while 循环，用来遍历链表结构的桶中的每一个节点，直到找到匹配的节点或到达链表的尾部。                do {                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        return e;                } while ((e = e.next) != null);            }        }
        //如果没有找到匹配的节点，则返回 null。        return null;    }

    /**     * Returns the value to which the specified key is mapped,     * or {@code null} if this map contains no mapping for the key.     *     * 
More formally, if this map contains a mapping from a key     * {@code k} to a value {@code v} such that {@code (key==null ? k==null :     * key.equals(k))}, then this method returns {@code v}; otherwise     * it returns {@code null}.  (There can be at most one such mapping.)     *     * 
A return value of {@code null} does not necessarily     * indicate that the map contains no mapping for the key; it's also     * possible that the map explicitly maps the key to {@code null}.     * The {@link #containsKey containsKey} operation may be used to     * distinguish these two cases.     *     * @see #put(Object, Object)     */    public V get(Object key) {        Node e;        return (e = getNode(hash(key), key)) == null ? null : e.value;    }

逻辑和 containsKey 一致，只是 getNode 之后，如果为 null 返回 null ， 否则返回 e.value 。

注：下面的作图可能并不严谨，只是帮助理解，如有偏差请勿较真。

Map myMap = new HashMap<>();Player kai = new Player("Kai");Player tom = new Player("Tom");Player amanda = new Player("Amanda");
myMap.put(kai, 42);myMap.put(tom, 200);myMap.put(amanda, 88);
assertTrue(myMap.containsKey(kai));

// 将Kai的名字更改为Erickai.setName("Eric");assertEquals("Eric", kai.getName());

Player eric = new Player("Eric");assertEquals(eric, kai);
// 现在，map中既不包含Kai也不包含Eric：assertFalse(myMap.containsKey(kai));assertFalse(myMap.containsKey(eric));

• 哈希码更改
  当你修改一个 HashMap 中的键时，该键的哈希码可能会更改，导致该键的哈希值不再与它当前所在的桶匹配。这将导致在使用该键进行查找时找不到相关的条目。