Java HashMap Hashcode

1.HashMap

"1" Traversal: HashMap unordered traversal

For (map.entry<string, String>m:map.entryset ()//key-value pairs, allow the key to be empty String
{
System.out.println (M.getkey () + ":" +m.getvalue ());
}

HashMap Source:

1. Transient entry[] table;
3. Static class Entry<k,v> implements map.entry<k,v> {
4. final K Key;
5. V value;
6. Entry<k,v> Next;
7. final int hash;
8. ......
9. }

adding elements

2. Public V put (K key, V value) {
4. //HashMap allow null keys and null values to be stored.
6. //When key is null, the Putfornullkey method is called, and value is placed in the first position of the array.
8. if (key = = null)
10. return Putfornullkey (value);
12. //The hash value is recalculated based on the keycode of the key.
14. int hash = hash (Key.hashcode ());
16. //Search the index of the specified hash value in the corresponding table.
18. int i = indexfor (hash, table.length);
20. //If the Entry at the I index is not NULL, the next element of the E element is traversed continuously through the loop.
22. For (entry<k,v> e = table[i]; E! = null; e = e.next) {
24. Object K;
26. //If a entry hash of the linked list at the I index is found to be equal to the hash of the new entry and the key is the same, the new entry overwrites the old entry and returns.
28. if (E.hash = = Hash && (k = e.key) = = Key | | key.equals (k)) {
30. V oldValue = E.value;
32. E.value = value;
34. E.recordaccess (this);
36. return oldValue;
38. }
40. }
42. //If the entry at the I index is null, there is no entry here.
44. modcount++;
46. //Add key, value to index at I.
48. AddEntry (hash, key, value, I);
50. return null;
    

Reading elements

2. Public V get (Object key) {
4. if (key = = null)
6. return Getfornullkey ();
8. int hash = hash (Key.hashcode ());
10. for (entry<k,v> e = table[indexfor (hash, table.length)];
12. E! = null;
14. E = e.next) {
16. Object K;
18. if (E.hash = = Hash && (k = e.key) = = Key | | key.equals (k)))
20. return e.value;
22. }
24. return null;
26. }

String equals

2. /** 
4. * Compares this string to the specified object. The result is {@code
6. * true} if and only if the argument are not {@code null} and is a {@code
8. * String} object that represents the same sequence of characters as this
10. * object.
12. *
14. * @param anobject
16. * The object to compare this {@code String} against
18. *
20. * @return {@code true} if the given object represents a {@code String}
22. * Equivalent to this string, {@code false} otherwise
24. *
26. * @see #compareTo (String)
28. * @see #equalsIgnoreCase (String)
30. */
32. public Boolean equals (Object anobject) {
34. if (this= = AnObject) {
36. return true;
38. }
40. if (anobject instanceof String) {
42. String anotherstring = (string) anobject;
44. int n = count;
46. if (n = = anotherstring.count) {
48. char v1[] = value;
50. char v2[] = Anotherstring.value;
52. int i = offset;
54. int j = Anotherstring.offset;
56. While (n--! = 0) {
58. if (v1[i++]! = v2[j++])
60. return false;
62. }
64. return true;
66. }
68. }
70. return false;
72. }

String hashcode

2. /** 
4. * Returns A hash code for this string. The hash code for a
6. * <code>String</code> object is computed as
8. * <blockquote><pre>
10. * s[0]*31^ (n-1) + s[1]*31^ (n-2) + ... + s[n-1]
12. * </pre></blockquote>
14. * Using <code>int</code> arithmetic, where <code>s[i]</code> is the
16. * <i>i</i>th character of the string, <code>n</code> is the length of
18. * The string, and <code>^</code> indicates exponentiation.
20. * (The hash value of the empty string is zero.)
22. *
24. * @return A hash code value for this object.
26. */
28. public int hashcode () {
30. int h = hash;
32. int len = count;
34. if (h = = 0 && len > 0) {
36. int off = offset;
38. char val[] = value;
42. For (int i = 0; i < len; i++) {
44. H = 31*h + val[off++];
46. }
48. hash = h;
50. }
52. return h;
54. }

hash function

2. /**
4. * Applies a supplemental hash function to a given hashcode, which
6. * Defends against poor quality hash functions. This is critical
8. * Because HashMap uses power-of-two length hash tables, that
10. * Otherwise encounter collisions for hashcodes this do not differ
12. * in lower bits. Note:null keys always maps to hash 0, thus index 0.
14. */
16. tatic int hash (int h) {
18. //This function ensures, hashcodes that differ
20. //constant multiples at each bit position has a bounded
22. //number of collisions (approximately 8 at default load factor).
24. H ^= (H >>> ) ^ (H >>> 12);
26. return H ^ (H >>> 7) ^ (H >>> 4);
28. }
32. /** 
34. * Returns index for hash code h.
36. */
38. static int indexfor (int h, int length) {
40. return H & (length-1);
42. }

Java HashMap Hashcode