【Data Structures】 12. Hashing, HashMap and HashSet in Java

The hashCode() method in Java is implemented in the Object class.

Basically, the hashCode() method provides a numeric representation of an object.

hashCode method in the String class uses the following formula.

s.charAt(0) * 31^(n-1) + s.charAt(1) * 31(n-2) + ... + s.charAt(n-1)

HashMap

The Map interface in Java is not an extension of the Collection interface. It starts off its own interface hierarchy.

The interface describes a mapping from keys to values, without duplicate keys, by definition.

As a result, maps provide a good way of searching for an object on the value of another.

Other than the fact that it is key and value mapping implementation. HashMap is a hashtable as we discussed so far.

Here are some code snippets from HashMap class (Java 7).

// The table, resized as necessary. Length MUST Always be a power of two.
Entry<K, V>[] table;

public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
table = new Entry[DEFAULT_INITIAL_CAPACITY];
init();
}

static class Entry<K, V> ... {
final K key;
V value;
Entry<K, V> next;
int hash;
Entry(int h, K k, V v, Entry<K, V> n) {
value = v;
next = n;
key = k;
hash = h;
}
}

public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K, V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}

static int indexFor(int h, int length) {
return h & (length - 1);
}

void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K, V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}

Major methods of the HashMap in java are:
put(key, value): associates the value with the key in the map.

get(key): returns the value of the key or null.

keySet(): returns a set view of the keys in the map.

values(): returns a collection view of the values in the map.

For keySet() and values() methods, we can use an Iterator to traverse the returned values.

A simple application: implementing the frequency count of words

// you can try to tune initial capacity and load factor.
// default values are 16 and 0.75 respectively.
Map<String, Integer> freqOfWords = new HashMap<String, Integer>(16, 0.65f);

String[] words = "coming together is a beginning keeping together is progress working together is success".split(" ");
for (String word : words) {
Integer frequency = freqOfWords.get(word);
if (frequency == null) {
frequency = 1;
} else {
frequency++;
}
freqOfWords.put(word, frequency);
}
Iterate all of the words and print each per one line

Iterator<String> itr = freqOfWords.keySet().iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}Or
for (String word : freqOfWords.keySet()) {
System.out.println(word);
}

HashSet
Java provides HashSet class which is a regular set in which all objects are distinct.

HashSet's major methods are:

add(key): adds a key to the set.

contains(key): return true if the set has that key.

iterator(): return an iterator over the elements.

HashSet class implements the Set interface using HashMap instance.

public class HashSet<E> implements Set<E> {
private ... HashMap<E, Object> map;
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();

public HashSet() {
map = new HashMap<>();
}

public boolean add(E e) {
return map.put(e, PRESENT) == null;
}
}

It creates HashMap instance and it uses HashMap's put method to add a new element but with dummy object as its value.
And, it adds, or puts, a new element only if it is not already present in the map.

It stores and retrieves elements by using a hash function that converts elements into an integer.