Java in HashSet detailed

The realization of HashSet

For HashSet, it is based on HASHMAP implementation, HashSet the bottom of the HashMap to save all the elements, so HashSet implementation is relatively simple, view the source code of HashSet, you can see the following code:

Java code

2. Public class Hashset<e>
4. extends Abstractset<e>
6. implements Set<e>, cloneable, Java.io.Serializable
8. {
10. //Use HashMap key to save all elements in HashSet
12. private transient hashmap<e,object> map;
14. //Define a dummy object as the value of HashMap
16. private Static final Object PRESENT = new Object ();
18. ...
20. //Initialize HashSet, the underlying initializes a HashMap
22. Public HashSet ()
24. {
26. Map = new hashmap<e,object> ();
28. }
30. //Create HashSet with the specified initialcapacity, Loadfactor
32. //actually is to create the HASHMAP with corresponding parameters
34. Public HashSet (int initialcapacity, float loadfactor)
36. {
38. Map = New Hashmap<e,object> (initialcapacity, loadfactor);
40. }
42. Public HashSet (int initialcapacity)
44. {
46. Map = new hashmap<e,object> (initialcapacity);
48. }
50. HashSet (int initialcapacity, float loadfactor, boolean dummy)
52. {
54. Map = new linkedhashmap<e,object> (initialcapacity
56. , Loadfactor);
58. }
60. //Call map's keySet to return all keys
62. Public iterator<e> Iterator ()
64. {
66. return Map.keyset (). iterator ();
68. }
70. ///Call HashMap the size () method returns the number of Entry, and the number of elements in the Set
72. public int size ()
74. {
76. return map.size ();
78. }
80. //Call HashMap's IsEmpty () to determine if the HashSet is empty,
82. //When the HashMap is empty, the corresponding HashSet is also empty
84. Public Boolean isEmpty ()
86. {
88. return Map.isempty ();
90. }
92. //Call HashMap ContainsKey to determine if the specified key is included
94. all the elements of//hashset are saved by the HASHMAP key .
96. Public Boolean contains (Object o)
98. {
100. return Map.containskey (o);
102. }
104. //Put the specified element in HashSet, that is, put the element as a key HashMap
106. Public Boolean add (E e)
108. {
110. return Map.put (E, PRESENT) = = null;
112. }
114. //Call the HashMap Remove method to delete the specified Entry, and then delete the corresponding element in the HashSet
116. Public boolean remove (Object o)
118. {
120. return Map.Remove (o) ==present;
122. }
124. //The Clear method of calling Map clears all Entry and clears all elements in HashSet
126. public void Clear ()
128. {
130. Map.clear ();
132. }
134. ...
136. }

As can be seen from the above source program, the implementation of HashSet is very simple, it just encapsulates a HashMap object to store all the collection elements, all the collection elements put into HashSet are actually saved by the key of HashMap, while the HASHMAP value is stored A PRESENT, which is a static object.

Most of the methods of HashSet are implemented by invoking the HashMap method, so HashSet and HashMap two sets are essentially the same in their implementations.
After mastering the above theoretical knowledge, take a look at an example program and test whether you really mastered the functions of the HashMap and HashSet collections.
Java code

2. class Name
4. {
6. private String first;
8. private String last;
12. Public Name (string First, string last)
14. {
16. This.first = First;
18. this.last = last;
20. }
24. public Boolean equals (Object o)
26. {
28. if (this= = O)
30. {
32. return true;
34. }
38. if (o.getclass () = = Name. Class)
40. {
42. Name n = (name) o;
44. return N.first.equals (first)
46. && n.last.equals (last);
48. }
50. return false;
52. }
54. }
58. Public class Hashsettest
60. {
62. public static void Main (string[] args)
64. {
66. set<name> s = new hashset<name> ();
68. S.add (new Name ("abc", "123"));
70. System.out.println (
72. S.contains (new Name ("abc", "123")));
74. }
76. }

After adding a new name ("abc", "123") object to HashSet in the above program, it is immediately determined by the program that the HashSet contains a new name ("abc", "123") object. Coarse looks, it is easy to assume that the program will output true.

Actually running the above program will see the program output false, this is because HashSet judge two objects equal to the standard in addition to the Equals () method is required to return true, but also requires two objects hashcode () return values equal. The above program does not override the name class's Hashcode () method, the Hashcode () return value of the two name objects is not the same, so HashSet treats them as 2 objects, so the program returns FALSE.

Thus, it is important to override the Equals (Object obj) method and the Hashcode () method of this class when we try to treat the object of a class as a HashMap key, or try to save the object of this class in HashSet. And the return values of the two methods must be consistent: when the two hashcode () return values of the class are identical, they should also return true through the Equals () method. In general, all key attributes that participate in the calculation of the hashcode () return value should be used as the criteria for the Equals () comparison.
The following program correctly rewrites the hashcode () and Equals () methods of the Name class, with the following procedures:
Java code

2. Class Name
4. {
6. private String first;
8. private String last;
10. Public Name (string First, string last)
12. {
14. This.first = First;
16. this.last = last;
18. }
20. //Determine if two Name is equal according to first
22. public Boolean equals (Object o)
24. {
26. if (this= = O)
28. {
30. return true;
32. }
34. if (o.getclass () = = Name. Class)
36. {
38. Name n = (name) o;
40. return n.first.equals (first);
42. }
44. return false;
46. }
50. //Hashcode () return value of Name object based on first calculation
52. public int hashcode ()
54. {
56. return First.hashcode ();
58. }
62. Public String toString ()
64. {
66. return "name[first=" + First + ", last=" + Last + "]";
68. }
70. }
74. public class HashSetTest2
76. {
78. public static void Main (string[] args)
80. {
82. hashset<name> set = new hashset<name> ();
84. Set.add (new Name ("abc", "123"));
86. Set.add (new Name ("abc", "456"));
88. SYSTEM.OUT.PRINTLN (set);
90. }
92. }

The above program provides a name class that overrides the Equals () and toString () two methods, both of which are judged by the first instance variable of the name class, and when the first instance variable of the two name object is equal, the two N The Hashcode () return value of the Ame object is also the same, and true is also returned by the Equals () comparison.

The main method of the program first adds the first name object to the HashSet, the name object is named "ABC", and then the program tries again to add a Name object "ABC" to the HashSet, it is clear that the new Na The Me object is added to the HashSet because the first of the name object you are trying to add is also "ABC", and HashSet will determine that the new name object here is the same as the original name object and therefore cannot be added, and the program will look at the output set collection at ① code. To the collection contains only one name object, which is the first name object that is "123".

Java in HashSet detailed