HashSet Implementation principle

1. HashSet Overview

HashSet implements the set interface, which is supported by a hash table (actually a hashmap instance). It does not guarantee the set's iteration order, especially it does not guarantee that the order is constant. This class allows the use of NULL elements.

2. Implementation of HashSet

If not, it is added to the linked list corresponding to the array index.

------------------------------------------------------------------------------------------

Set implementation class can not have duplicate elements in the collection object, HashSet is the same as he used an identity to determine the elements of the non-repetition, hashset with an algorithm to ensure that hashset elements are not duplicated, hashset using a hashing algorithm, the underlying array to store data. Default initialization capacity 16, load factor 0.75

The method of Hashcode () in the object class is that all subclasses inherit this method, and this method calculates a hash (hash) value return using the hash algorithm, and the hashset will use the hash code value to take the modulus of the array length. Modulo (where the object is to be placed in the array) determines whether the elements in the array are the same as the contents of the objects to be joined, and if they are different, they are added.

Hash algorithm is a hashing algorithm.

Set hs=new HashSet ();

Hs.add (o);
|
O.hashcode ();
|
o% Current Total Capacity (0--15)
|
| No conflicts
If there is a conflict-----------------direct storage
|
| Conflict occurred
| False (Not equal)
O1.equals (O2)-------------------Find a vacancy to add
|
| Yes (equal)
Do not add

The principle of overriding the Hashcode () method:
1. Be sure to return the same hashcode value to the objects that we think are the same
2, try to let those we think that different objects return different hashcode values, otherwise, will increase the probability of conflict.
3, as far as possible to let Hashcode value Liekai (two value with a different or operation can make the result range wider)

The implementation of HashSet is relatively simple, the related HashSet operations are basically directly called the underlying hashmap of the relevant methods to complete, we should save to the object in HashSet hashcode () and Equals (), Since the object is added to the HashSet, the Hashcode method is called first to calculate the hash value of the object, and then the hash method in the HashMap is called according to the hash value, the resulting value & (LENGTH-1) Gets the index of the save position of the object in the HashMap transient entry[] table, and then finds the object that is saved in the array at that index position, and calls the Equals method to compare whether the two objects are equal or not, if the equality is not added. Note: Therefore, the custom class in the collection object to be deposited in hashset must overwrite the hashcode (), Equals () two methods to ensure that the elements in the collection are not duplicated. When overriding the Equals () and Hashcode () methods, the Hashcode () method of the same object returns the same value, overriding the Equals () method to determine its contents. In order to ensure the efficiency, so when covering the Hashcode () method, also try to make different objects as far as possible to return different hash code values.

If the elements in the array and the hashcode () of the object to be joined return the same hash value (the same object), the Equals () method is used to determine whether the contents of the two objects are the same.

------------------------------------------------------------------------------------------

The source code for HashSet is as follows:

[Java]View PlainCopy

2. Public class Hashset<e>
4. Extends abstractset<e>
6. Implements Set<e>, Cloneable, java.io.Serializable
8. {
10. Static final long serialversionuid = -5024744406713321676l;
14. The underlying uses HashMap to hold all the elements in the hashset.
16. Private transient hashmap<e,object> map;
20. Defines a dummy object as the value of HashMap, which defines this object as static final.
22. Private static final Object PRESENT = new Object ();
26. /**
28. * The default parameterless constructor constructs an empty hashset.
30. *
32. * The actual underlying will initialize an empty HashMap and use the default initial capacity of 16 and load factor 0.75.
34. */
36. Public HashSet () {
38. Map = new hashmap<e,object> ();
40. }
44. /**
46. * Constructs a new set containing the elements in the specified collection.
48. *
50. * The actual underlying uses the default load factor of 0.75 and is sufficient to contain the specified
52. * The initial capacity of all elements in collection to create a hashmap.
54. * @param c where the elements will be stored in the collection in this set.
56. */
58. Public HashSet (COLLECTION<? extends e> c) {  
60. Map = New Hashmap<e,object> (Math.max ((int) (C.size ()/.75f) + 1, 16));
62. AddAll (c);
64. }
68. /**
70. * Constructs an empty hashset with the specified initialcapacity and loadfactor.
72. *
74. * The actual bottom layer constructs an empty hashmap with corresponding parameters.
76. * @param initialcapacity initial capacity.
78. * @param loadfactor loading factor.
80. */
82. Public HashSet (int initialcapacity, float loadfactor) {
84. Map = New Hashmap<e,object> (initialcapacity, loadfactor);
86. }
90. /**
92. * Constructs an empty hashset with the specified initialcapacity.
94. *
96. * The actual bottom layer constructs an empty hashmap with corresponding parameters and load factor loadfactor of 0.75.
98. * @param initialcapacity initial capacity.
100. */
102. Public HashSet (int initialcapacity) {
104. Map = new hashmap<e,object> (initialcapacity);
106. }
110. /**
112. * Constructs a new empty-link hash collection with the specified initialcapacity and loadfactor.
114. * This constructor is for package access, not public, and is actually just a support for linkedhashset.
116. *
118. * The actual underlying will be implemented with an empty Linkedhashmap instance constructed with the specified parameters.
120. * @param initialcapacity initial capacity.
122. * @param loadfactor loading factor.
124. * @param dummy mark.
126. */
128. HashSet (int initialcapacity, float loadfactor, boolean dummy) {
130. Map = New Linkedhashmap<e,object> (initialcapacity, loadfactor);
132. }
136. /**
138. * Returns an iterator that iterates over the elements in this set. The order of the returned elements is not specific.
140. *
142. * The underlying actual call to the underlying HashMap keyset to return all keys.
144. * Visible hashset elements, just stored in the underlying HashMap key,
146. * Value uses a static final object identifier.
148. * The iterator that iterates over the elements in this set @return.
150. */
152. Public iterator<e> Iterator () {
154. Return Map.keyset (). iterator ();
156. }
160. /**
162. * Returns the number of elements in this set (capacity of Set).
164. *
166. * The size () method of the underlying actual call to HashMap returns the number of entry, and the number of elements in the set is obtained.
168. * @return The number of elements in this set (capacity of Set).
170. */
172. public int size () {
174. return Map.size ();
176. }
180. /**
182. * Returns True if this set contains no elements.
184. *
186. * The underlying actual call to HashMap IsEmpty () determines whether the hashset is empty.
188. * @return Returns True if this set contains no elements.
190. */
192. Public Boolean IsEmpty () {
194. return Map.isempty ();
196. }
200. /**
202. * Returns True if this set contains the specified element.
204. * More precisely, when and only if this set contains a satisfying (o==null? E==null:o.equals (e))
206. * When the E element returns true.
208. *
210. * The underlying actual call to HashMap ContainsKey determines whether the specified key is included.
212. * @param o The existence of the element that has been tested in this set.
214. * @return Returns True if this set contains the specified element.
216. */
218. Public Boolean contains (Object o) {
220. return Map.containskey (o);
222. }
226. /**
228. * If the specified element is not already contained in this set, the specified element is added.
230. * More specifically, if this set does not contain the content (E==null? E2==null:e.equals (E2))
232. * element E2, the specified element e is added to this set.
234. * If this set already contains the element, the call does not change the set and returns false.
236. *
238. * The underlying actually puts the element as key into the HashMap.
240. * Because the put () method of HashMap adds Key-value pair, when the new is placed in the entry of HashMap key
242. * Same as key with entry in the Set (Hashcode () return value is equal, also return true by equals),
244. * The value of the newly added entry will overwrite the value of the original entry, but there will be no change to key.
246. * Therefore, if an existing element is added to HashSet, the newly added collection element will not be placed in the HashMap,
248. * The original element will not have any changes, which satisfies the feature that the element in set does not repeat.
250. * @param e is added to the element in this set.
252. * @return Returns True if this set does not already contain the specified element.
254. */
256. Public Boolean Add (E e) {
258. Return Map.put (E, PRESENT) = =null;
260. }
264. /**
266. * If the specified element is present in this set, it is removed.
268. * More specifically, if this set contains an element e that satisfies (o==null. E==null:o.equals (e)),
270. * Remove it. Returns True if this set already contains the element
272. * (or: Returns True if this set changes because of a call). (Once the call returns, the set no longer contains the element).
274. *
276. * The lower layer actually calls HashMap's Remove method to delete the specified entry.
278. * @param o An object that needs to be removed if it exists in this set.
280. * @return Returns True if the set contains the specified element.
282. */
284. Public boolean remove (Object o) {
286. return Map.Remove (o) ==present;
288. }
292. /**
294. * Removes all elements from this set. When this call returns, the set will be empty.
296. *
298. * The lower layer actually calls HashMap's clear method to empty all elements in the entry.
300. */
302. Public void Clear () {
304. Map.clear ();
306. }
310. /**
312. * Returns a shallow copy of this HashSet instance: The elements themselves are not copied.
314. *
316. * The underlying actually calls HashMap's Clone () method, gets the shallow copy of the HashMap, and sets it to HashSet.
318. */
320. Public Object Clone () {
322. try {
324. hashset<e> Newset = (hashset<e>) super.clone ();
326. Newset.map = (hashmap<e, object>) Map.clone ();
328. return newset;
330. } catch (Clonenotsupportedexception e) {
332. Throw new Internalerror ();
334. }
336. }
338. }

HashSet Implementation principle