Shulou(Shulou.com)06/01 Report--

This article mainly explains why Java rewrites hashCode after rewriting equals. Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn why Java rewrote hashCode after rewriting equals.

First, look at the phenomenon public class TestDemo {public static void main (String [] args) {Person p1 = new Person ("Allen"); Person p2 = new Person ("Allen"); System.out.println (p1.equals (p2));} static class Person {public Person (String name) {this.name = name;} private String name Public String getName () {return name;} public void setName (String name) {this.name = name;} @ Override public boolean equals (Object o) {if (this = = o) return true; if (o = = null | | getClass ()! = o.getClass ()) return false; Person person = (Person) o Return Objects.equals (name, person.name);}}

When the above code finishes running, you can see that the output is true.

As you can see, because after rewriting the equals method, as long as the type is the same and the name is the same, it is assumed that the two objects are the same, instead of using the memory address by default to compare whether they are the same or not.

This is generally needed in our business code. For example, if a person's name is equal, he or she is the same person. Normally, isn't it enough for us to rewrite the equals judgment that it is equal? why rewrite hashCode? let's look at another example.

Second, why rewrite hashCode

According to the code at the beginning, instead of rewriting hashCode, let's do a requirement to filter out duplicates, such as two people named Allen, but we only save one

So at this time we use HashMap to do it, because the key of HashMap is unique, de-duplicated, we rewrite the equals method of Person, as long as the name is equal, it is the same object, then HashMap should recognize it and remove it, right? Let's look at the results:

Public static void main (String [] args) {Person p1 = new Person ("Allen"); Person p2 = new Person ("Allen"); Map map = new HashMap (); map.put (p1, p1.getName ()); map.put (p2, p2.getName ()); System.out.println ("map length:" + map.size ()) Map.forEach ((key, value)-> {System.out.println (key.getName ());});}

Isn't it amazing that there is no weight removed, and both of them are saved in HashMap, which does not achieve the desired effect? why?

First of all, the internal memory value of HashMap is an array, but the search speed of HashMap is very fast, basically O (1).

This is because it uses the Hash algorithm. After HashMap hash the key, an integer value is obtained. This integer value is the subscript stored in the final storage array. Of course, there is a series of subsequent processing, and you can consult the relevant data for in-depth understanding. Here is only a simple description.

Let's go on to the above question, because we did not rewrite the hashCode method. Although equals compares whether the name values of the two objects are the same, the stored value of HashMap is calculated by hashCode, and a value is stored in the corresponding array subscript.

So the hashCode values returned by the p1 and p2 values in our above code are different, so the calculated subscript is also different, which causes them to be stored under different array subscripts by HashMap. This is why the deduplication is not successful.

Looking at the figure above, the names of the two objects in the heap address are the same, but the hashCode is different. If the name is compared and hash is done, it is equal, but HashMap uses hashCode, so we need to rewrite the hashCode method. According to our business guarantee, the hashCode of the same meaning belonging to an object at the business level should also be consistent.

3. Implementation code public class TestDemo {public static void main (String [] args) {Person p1 = new Person ("Allen"); Person p2 = new Person ("Allen"); System.out.println (p1.hashCode ()); System.out.println (p2.hashCode ()); Map map = new HashMap (); map.put (p1, p1.getName ()) Map.put (p2, p2.getName ()); map.get (p1); System.out.println ("map length:" + map.size ()); map.forEach ((key, value)-> {System.out.println (key.getName ());});} static class Person {public Person (String name) {this.name = name } private String name; public String getName () {return name;} public void setName (String name) {this.name = name;} @ Override public boolean equals (Object o) {if (this = = o) return true; if (o = = null | | getClass ()! = o.getClass ()) return false Person person = (Person) o; return Objects.equals (name, person.name);} @ Override public int hashCode () {return Objects.hash (name);}

As you can see, when we rewrite hashCode to use the name of the object as the calculated value to generate the final hash value, so that HashMap can help us route two objects to a subscript, and then through equals comparison, determine that the two objects are the same object, so as to achieve the effect of de-duplication.

At this point, I believe you have a deeper understanding of why Java rewrote hashCode after rewriting equals, so you might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.