opendressinghash //use resize array

 public class opendressinghash<Key, Value> {
         private static final int INIT_CAPACITY = 4;

         private int n;
         private int m;
         private Key[] keys;
         private Value[] vals;   

         public opendressinghash() {
             this(INIT_CAPACITY);
         }

         public opendressinghash(int capacity) {
             m = capacity;
             n = 0;
             keys = (Key[])   new Object[m];
             vals = (Value[]) new Object[m];
         }

         public int size() {
             return n;
         }

         public boolean isEmpty() {
             return size() == 0;
         }

         public boolean contains(Key key) {
             if (key == null) throw new NullPointerException("argument to contains() is null");
             return get(key) != null;
         }

         private int hash(Key key) {
             return (key.hashCode() & 0x7fffffff) % m;
         }

         private void resize(int capacity) {
             opendressinghash<Key, Value> temp = new opendressinghash<Key, Value>(capacity);
             for (int i = 0; i < m; i++) {
                 if (keys[i] != null) {
                     temp.put(keys[i], vals[i]);
                 }
             }
             keys = temp.keys;
             vals = temp.vals;
             m    = temp.m;
         }

         public void put(Key key, Value val) {
             if (key == null) throw new NullPointerException("first argument to put() is null");

             if (val == null) {
                 delete(key);
                 return;
             }

             if (n >= m/2) resize(2*m);

             int i;
             for (i = hash(key); keys[i] != null; i = (i + 1) % m) {
                 if (keys[i].equals(key)) {
                     vals[i] = val;
                     return;
                 }
             }
             keys[i] = key;
             vals[i] = val;
             n++;
         }

         public Value get(Key key) {
             if (key == null) throw new NullPointerException("argument to get() is null");
             for (int i = hash(key); keys[i] != null; i = (i + 1) % m)
                 if (keys[i].equals(key))
                     return vals[i];
             return null;
         }

         public void delete(Key key) {
             if (key == null) throw new NullPointerException("argument to delete() is null");
             if (!contains(key)) return;

             // find position i of key
             int i = hash(key);
             while (!key.equals(keys[i])) {
                 i = (i + 1) % m;
             }

             // delete key and associated value
             keys[i] = null;
             vals[i] = null;

             // rehash all keys in same cluster
             i = (i + 1) % m;
             while (keys[i] != null) {
                 // delete keys[i] an vals[i] and reinsert
                 Key   keyToRehash = keys[i];
                 Value valToRehash = vals[i];
                 keys[i] = null;
                 vals[i] = null;
                 n--;
                 put(keyToRehash, valToRehash);
                 i = (i + 1) % m;
             }

             n--;

             // halves size of array if it's 12.5% full or less
             if (n > 0 && n <= m/8) resize(m/2);

             assert check();
         }

         private boolean check() {

             // check that hash table is at most 50% full
             if (m < 2*n) {
                 System.err.println("Hash table size m = " + m + "; array size n = " + n);
                 return false;
             }

             // check that each key in table can be found by get()
             for (int i = 0; i < m; i++) {
                 if (keys[i] == null) continue;
                 else if (get(keys[i]) != vals[i]) {
                     System.err.println("get[" + keys[i] + "] = " + get(keys[i]) + "; vals[i] = " + vals[i]);
                     return false;
                 }
             }
             return true;
         }

     }