Does the hashcode method need to be rewritten after the equals method of the object is rewritten?

First, let's talk about the recommended situation: for example, when your object wants to be put into a set or a map key (non-Hash set and map, such as treeset and treemap ), then you must override the equals () method to ensure uniqueness. Of course, in this case, you do not want to rewrite the hashcode () method, and there is no error. However, for a good programming style, you should rewrite the hashcode () method while rewriting the equals () method.

Then let's talk about the situation where hashcode () must be rewritten:
If your object is to be placed in a Hash Storage set (such as hashset and hashset) or as a key of a hash map (such as hashmap and linkedhashmap, while rewriting the equals () method, you must override the hashcode () method.

Here I want to explain why Sun designers need to design the hashcode method. Maybe you should know when to rewrite it.
The data structure has a data structure that exists to improve the search efficiency-the hash list. The hash list is actually a promotion of the General array concept, because it can directly address the array, therefore, we can access any element of the array in O (1) Time. Thinking has a simple implementation of hashmap in Java. Let's take a look at it and you will understand:

 

1. //: Containers/simplehashmap. Java

2. // A demonstration hashed map.

3. Import java. util .*;

4. Import net. mindview. util .*;

6. Public class simplehashmap <K, V> extends abstractmap <K, V> {

7. // Choose a prime number for the hash table

8. // Size, to achieve a uniform distribution:

9. Static final int size = 997;

10. // You can't have a physical array of generics,

11. // But you can upcast to one:

12. @ Suppresswarnings ("unchecked ")

13. Counter list <mapentry <K, V> [] buckets =

14. New shortlist [size]; // each item in the list array is a list, and the array subscript is the return value of the hashcode method, which is obtained through the hash function, which is equivalent to the keyword of the hash list, it also represents the keywords of each object. (A New Generic Array cannot be displayed, but you can reference A New Generic Array. If necessary, you can convert an ordinary array to a generic array ).

15. Public v put (K key, V value) {// put this key pair value into hashmap.

16. V oldvalue = NULL;

17. Int Index = math. ABS (key. hashcode () % size; // here, a keyword is obtained through processing the return value of hashcode by the hash function. It represents the position of the object in the array and is both an array subscript.

18. If (buckets [Index] = NULL)

19. Buckets [Index] = new partition list <mapentry <K, V> (); // if this is the first time the array subscript is hashed, a new partition list is generated, you can see that mapentry <K, V> keys and values are saved in it.

20. Your list <mapentry <K, V> bucket = buckets [Index]; // assign the value of your list to a bucket. Then, you can operate on this bucket directly.

21. Mapentry <K, V> pair = new mapentry <K, V> (Key, value );

22. Boolean found = false;

23. Listiterator <mapentry <K, V> it = bucket. listiterator ();

24. While (it. hasnext ()){

25. Mapentry <K, V> ipair = it. Next ();

26. If (ipair. getkey (). Equals (key) {// if the same key value already exists, update the value.

27. Oldvalue = ipair. getvalue ();

28. It. Set (pair); // replace old with new

29. Found = true;

30. Break;

31. }

32. }

33. If (! Found)

34. Buckets [Index]. Add (pair); // if it is a new key value, directly add it to this sort list.

35. Return oldvalue;

36. }

37. Public v get (Object key) {// see how hashmap uses the hashcode method to quickly locate the key value.

38. Int Index = math. ABS (key. hashcode () % size; [color = Red] // generates an array subscript in the same way as the put method, because it is stored in this place when I save it, then, access buckets [Index] directly. [/Color]

39. If (buckets [Index] = NULL) return NULL; // directly access the list of objects under the array. If it is null, return.

40. For (mapentry <K, V> ipair: buckets [Index]) // Why should we use the sorted list? Because the hash code generated by the hashcode method cannot completely determine an object, that is to say, it will "collide" with other objects, that is, hash to the same Array subscript. The way to solve this problem is to define a list to save them, but in this list, we must ensure that the equals method can be used to determine the identity of an object. That is why many people say that hashcode () is equal, equals () is not necessarily equal, and equals () is equal to two objects, hashcode () must be equal. Therefore, linear search is directly performed on the sorted list.

41. If (ipair. getkey (). Equals (key ))

42. Return ipair. getvalue ();

43. Return NULL;

44. }

45. Public set <map. Entry <K, V> entryset (){

46. Set <map. Entry <K, V> set = new hashset <map. Entry <K, V> ();

47. For (catalog list <mapentry <K, V> Bucket: buckets ){

48. If (bucket = NULL) continue;

49. For (mapentry <K, V> mpair: bucket)

50. Set. Add (mpair );

51. }

52. Return set;

53. }

54. Public static void main (string [] ARGs ){

55. Simplehashmap <string, string> M =

56. New simplehashmap <string, string> ();

57. M. putall (countries. capitals (25 ));

58. System. Out. println (m );

59. System. Out. println (M. Get ("Eritrea "));

60. System. Out. println (M. entryset ());

61. }

62. }/* Output:

63. {Cameroon = Yaounde, Congo = Brazzaville, Chad = N' Djamena, Cote d' ivoir (Ivory Coast) = California, Central African Republic = Bangui, Guinea = Conakry, Botswana = Gaberone, bissau = Bissau, Egypt = Cairo, Angola = Luanda, Burkina Faso = California, Eritrea = Asmara, the Gambia = Banjul, Kenya = Nairobi, Gabon = Libreville, Cape Verde = Praia, algeria = Algiers, Comoros = Moroni, Equatorial Guinea = Malabo, Burundi = Beijing, Benin = Porto-Novo, Bulgaria = Sofia, Ghana = Accra, region = dijiboti, region = Addis Ababa}

64. Asmara

65. [Cameroon = Yaounde, Congo = Brazzaville, Chad = N' Djamena, Cote d' ivoir (Ivory Coast) = California, Central African Republic = Bangui, Guinea = Conakry, Botswana = Gaberone, bissau = Bissau, Egypt = Cairo, Angola = Luanda, Burkina Faso = California, Eritrea = Asmara, the Gambia = Banjul, Kenya = Nairobi, Gabon = Libreville, Cape Verde = Praia, algeria = Algiers, Comoros = Moroni, Equatorial Guinea = Malabo, Burundi = Beijing, Benin = Porto-Novo, Bulgaria = Sofia, Ghana = Accra, region = dijiboti, region = Addis Ababa

How? Now we should know the role of the hashcode method, which is used to improve efficiency. There is a saying: Hashing for speed. Because the hash set and map are based on the hashcode method to find objects, you must overwrite the hashcode method when using these classes, instead of the hash set and map, for example, treeset and treemap, they only need the equals method to uniquely identify the object. In this case, it must be clear.

Does the hashcode method need to be rewritten after the equals method of the object is rewritten?