Implement Hash Map Using Primitive Types

A small coding test that I encountered today.

Question

Using only primitive types, implement a fixed-size hash map that associates string keys with arbitrary data object references (you don't need to copy the object). Your data structure should be optimized for algorithmic runtime and memory usage. You should not import any external libraries, and may not use primitive hash map or dictionary types in languages like Python or Ruby.

The solution should be delivered in one class (or your language's equivalent) that provides the following functions:

• constructor(size): return an instance of the class with pre-allocated space for the given number of objects.
• boolean set(key, value): stores the given key/value pair in the hash map. Returns a boolean value indicating success / failure of the operation.
• get(key): return the value associated with the given key, or null if no value is set.
• delete(key): delete the value associated with the given key, returning the value on success or null if the key has no value.
• float load(): return a float value representing the load factor (`(items in hash map)/(size of hash map)`) of the data structure. Since the size of the dat structure is fixed, this should never be greater than 1.

If your language provides a built-in hashing function for strings (ex. `hashCode` in Java or `__hash__` in Python) you are welcome to use that. If not, you are welcome to do something naive, or use something you find online with proper attribution.

Solution

Key to construct a hash map is to construct several key-value entries.

 package datastructures.map;

 public class MyEntry<K, V> {
     private final K key;
     private V value;

     public MyEntry(K key, V value) {
         this.key = key;
         this.value = value;
     }

     public K getKey() {
         return key;
     }

     public V getValue() {
         return value;
     }

     public void setValue(V value) {
         this.value = value;
     }
 }

 package datastructures.map;

 // import datastructures.map.MyEntry;

 public class MyMap<K, V> {
     private int fullSize;
     private int size;
     private int DEFAULT_CAPACITY = 16;

     private MyEntry<K, V>[] map = new MyEntry[DEFAULT_CAPACITY];

     public MyMap(int size) {
         this.size = 0;
         this.map = new MyEntry[size];
         this.fullSize = size;
     }

     public V get(K key) {
         for (int i = 0; i < size; i++) {
             if (map[i].getKey().equals(key)) {
                 return map[i].getValue();
             }
         }
         return null;
     }

     public boolean set(K key, V value) {
         boolean insert = true;
         for (int i = 0; i < size; i++) {
             if (map[i].getKey().equals(key)) {
                 map[i].setValue(value);
                 insert = false;
             }
         }
         if (insert) {
             if (size >= fullSize) {
                 return false;
             }
             else {
                 map[size] = new MyEntry(key, value);
                 size++;
             }
         }
         return true;
     }

     public V delete(K key) {
         for (int i = 0; i < size; i++) {
             if (map[i].getKey().equals(key)) {
                 V value = map[i].getValue();
                 map[i] = null;
                 condenseArray(i);
                 return value;
             }
         }
         return null;
     }

     public float load() {
         return (float)size / (float)fullSize;
     }

     private void condenseArray(int start) {
         size--;
         for (int i = start; i < size; i++) {
             map[i] = map[i + 1];
         }
     }

  }

 package datastructures.map;

 public class Test {
     public static void main(String[] args) {
         int size = 8;
         MyMap<Character, Integer> test = new MyMap<Character, Integer>(size);
         test.set('a', 1);
         test.set('b', 2);
         test.set('c', 3);
         test.set('d', 4);
         System.out.println(test.get('a'));
         System.out.println(test.set('a', 2));
         System.out.println(test.get('a'));
         System.out.println(test.load());
         test.delete('b');
         System.out.println(test.load());
     }
 }

More basic knowledge about Java

Package and Import

Classes under same package need not import each other.

Here, we set three classes in package datastructures.map, and my current path is /home/Desktop

Then, I need to make a directory of datastructures/map under Desktop and put three source codes in that directory.

Meanwhile, I need to compile under Desktop directory.

Tutorialspoint

To compile the Java programs with package statements you have to do use -d option as shown below.

javac -d Destination_folder file_name.java

There can be only one package statement in each source file, and it applies to all types in the file.

Two major results occur when a class is placed in a package:

1. The name of the package becomes a part of the name of the class, as we just discussed in the previous section.

2. The name of the package must match the directory structure where the corresponding bytecode resides.

Constructor

Constructor for object should not include inner types.

For example

public MyMap<K, V>() {}           is wrong!

public MyMap() {}　　　　　　　  is right!

Public Class

(referrence: Tutorialspoint)

Four access level for classes:

1. Visible to the package. the default. No modifiers are needed.

2. Visible to the class only (private).

3. Visible to the world (public).

4. Visible to the package and all subclasses (protected).

Access Control and Inheritance:

1. Methods declared public in a superclass also must be public in all subclasses.

2. Methods declared protected in a superclass must either be protected or public in subclasses; they cannot be private.

3. Methods declared without access control (no modifier was used) can be declared more private in subclasses.

4. Methods declared private are not inherited at all, so there is no rule for them.