Reprinted from:/u012767369/article/details/79362752
The relationship between the () method and hashcode() method—the design principle of hashCode method
1) If the two objects are the same (that is, return true with equals comparison), then their hashCode values must be the same;
2) If two objects are different (i.e., if they compare equals, return false), then their hashCode values may be the same or may be different;
3) If the hashCodes of two objects are the same (there is a hash conflict), then they may be the same or different (i.e., the equals comparison may be false or true)
4) If the hashCodes of the two objects are different, then they must be different (that is, use equals comparison to return false)
hashCode() returns a hash value, while equals() is used to determine whether two objects are equivalent. The hash values of two equivalent objects must be the same, but the hash values of two equivalent objects may not be the same.
2. Rewrite the equals() method—pseudocode
1) Reflexivity: (A) Return true
2) Symmetry: If (B) returns true, then (A) also needs to return true
3) Transitiveness: If (B) returns true and (C) is true, then (C) must also be true. To put it bluntly, A = B, B = C, then A = C.
4) Consistency: As long as the state of objects A and B does not change, (B) must always return true.
5)(null) To return false.
The hashCode() method should always be overridden when overwriting the equals() method to ensure that the hash values of the two equivalent objects are also equal.
3. Rewrite the equals() method—The specific steps are divided into two steps. First, rewrite the equals() method, and then rewrite the hashCode() method.
Rewrite the equals() method
Sample Class
class Coder{
private String name;
private int age;
}
Because the default equals() actually determines whether two references point to the same object intrinsic, it is equivalent to ==, and the following three steps are followed.
1) Determine whether it is equal to yourself
if(otherr == this)
return true;
2) Use the instanceof operator to determine whether other is an object of type Coder
if(!(other instanceof Coder))
return false;
3) Compare the data fields, name and age you customize in the Coder class. None of them are missing.
Coder o = (Coder)other;
return (name) && == age;
Note: There is a cast in step 3. If someone passes an Integer class object into this equals, will he throw a ClassCastException? This worry is actually redundant. Because we have made the judgment of instanceof in the second step, if other is a non-Coder object, or even other is null, then false will be directly returned in this step, so that the subsequent code will not be executed. The above three steps are also the steps recommended in <Effective Java>, which can basically ensure that there is no accident.
Rewrite hashcode() method
After rewriting the equals() method, you must re-hashcode method. When rewriting, you must pay attention to ensuring that all members of the Coder object can be reflected in hashCode (key)
@Override
public int hashCode(){
int result = 17;
result = result * 31 + ();
result = result * 31 + age;
return result;
}
PS: The implementation of hashCode() in String is s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
It can be seen that the ASCII code of each character is calculated to the n-1 power and then summed it. This can avoid the same hashCode in the two different Strings to the greatest extent. As for why 31 is selected, if you are interested, you can take a look at this:/nullllun/p/
4. Risk of rewriting equals() method without rewriting hashCode() method
In Java, the hashCode() method is used to determine which bucket an object should be located, and then search in the corresponding linked list. Ideally, if your hashCode() method is robust enough, then each bucket will have only one node, which realizes the constant-level time complexity of the query operation. Once you rewrite the equals() method but not the hashCode() method, the object returned to true will be placed in different buckets due to different hashCodes, and in theory it should be placed in a bucket. At the same time, when querying, the specified element will not be found (the target object with equals true) due to locations to different bit buckets. Therefore, the reason for overriding hashCode is that when (B) returns true, the hashCode() of A and B will return the same value.
PS: hashCode() serves a hash table, used to quickly locate the position of elements in the array. The hashCode() method cannot return a fixed number every time. In this way, hashMap and hashSet lose their meaning, and the hash table degenerates into a linked list. Each query just traverses the linked list, completely losing the function of hash.
copy from：/u012767369/article/details/79362752
_________________________________________________
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = count;
if (n == ) {
char v1[] = value;
char v2[] = ;
int i = offset;
int j = ;
while (n– != 0) {
if (v1[i++] != v2[j++])
return false;
}
return true;
}
}
return false;
}
Obviously, this is a content comparison, and it is no longer a comparison of addresses. In turn, classes such as Math, Integer, Double, etc. have rewrite the equals() method, thus making content comparisons. Of course, the basic type is to compare values.
Its properties are:
- Reflexive. For any
nullthe reference value x,(x)Must betrue。 - symmetry. For any
nullReference value ofxandy, if and only if(y)yestruehour,(x)Tootrue。 - Transitive. For any
nullReference value ofx、yandz,if(y)yestrue,at the same time(z)yestrue,So(z)Must betrue。 - consistency. For any
nullReference value ofxandy, if the object information used for equals comparison has not been modified, multiple calls(y)Or return consistentlytrueOr return consistentlyfalse。 - For any
nullReference value ofx，(null)returnfalse。
forObjectFor class,equals()The method implements the equivalent relationship with the greatest possibility of difference on the object, that is, for any non-nullReference value ofxandy, if and only ifxandyThe method will return the same objecttrue。
It should be noted that when the equals() method is override, hashCode() will also be override. According to the general implementation of hashCode() method, the hash codes of equal objects must be equal.
Detailed explanation of hashcode() method
hashCode()The method returns a hash code value to the object. This method is used for hash tables, such as HashMap.
Its properties are:
- During execution of a Java application, if the information provided by an object to equals for comparison is not modified, the object is called multiple times
hashCode()method, the method must consistently return the same integer. - If two objects are based on
equals(Object)The methods are equal, then the respective methods are calledhashCode()The method must produce the same integer result. - Not required based on
equals()Two objects whose methods are not equal, call their respective oneshashCode()The method must produce different integer results. However, programmers should be aware that different integer results are produced for different objects, which may improve the performance of the hash table.