Java - HashMap 的 key 更改后能否正确获取 value？

packagetech.luxsun.interview.luxinterviewstarter.collection;
importlombok.AllArgsConstructor;
importlombok.Data;
importlombok.NoArgsConstructor;
importjava.util.HashMap;
/*** @author Lux Sun* @date 2021/4/22*/publicclassMapDemo0 {
publicstaticvoidmain(String[] args) {
HashMap<Object, Object>map=newHashMap<>();
// Person CasePersonp=newPerson("Bob", 12);
map.put(p, "person");
System.out.println(p.hashCode());
System.out.println(map.get(p));
p.setAge(13);
System.out.println(p.hashCode());
System.out.println(map.get(p));
// Student CaseStudentstu=newStudent("Bob", 12);
map.put(stu, "student");
System.out.println(stu.hashCode());
System.out.println(map.get(stu));
stu.setAge(13);
System.out.println(stu.hashCode());
System.out.println(map.get(stu));
    }
}
@Data@AllArgsConstructor@NoArgsConstructorclassPerson {
privateStringname;
privateIntegerage;
publicinthashCode() {
return123456;
    }
}
@Data@AllArgsConstructor@NoArgsConstructorclassStudent {
privateStringname;
privateIntegerage;
}

123456person123456person71154student71213null

publicinthashCode() {
intPRIME=true;
intresult=1;
Object$age=this.getAge();
intresult=result*59+ ($age==null?43 : $age.hashCode());
Object$name=this.getName();
result=result*59+ ($name==null?43 : $name.hashCode());
returnresult;
}

/*** Returns the value to which the specified key is mapped,* or {@code null} if this map contains no mapping for the key.** <p>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.)** <p>A return value of {@code null} does not <i>necessarily</i>* 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)*/publicVget(Objectkey) {
Node<K,V>e;
return (e=getNode(hash(key), key)) ==null?null : e.value;
}
/*** 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.*/staticfinalinthash(Objectkey) {
inth;
return (key==null) ?0 : (h=key.hashCode()) ^ (h>>>16);
}
/*** Implements Map.get and related methods** @param hash hash for key* @param key the key* @return the node, or null if none*/finalNode<K,V>getNode(inthash, Objectkey) {
Node<K,V>[] tab; Node<K,V>first, e; intn; Kk;
if ((tab=table) !=null&& (n=tab.length) >0&&        (first=tab[(n-1) &hash]) !=null) {
if (first.hash==hash&&// always check first node            ((k=first.key) ==key|| (key!=null&&key.equals(k))))
returnfirst;
if ((e=first.next) !=null) {
if (firstinstanceofTreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash==hash&&                    ((k=e.key) ==key|| (key!=null&&key.equals(k))))
returne;
            } while ((e=e.next) !=null);
        }
    }
returnnull;
}