Re: A java program (MyHashTable)

On Apr 22, 7:17 pm, Sagarika <SonamSenSha...@gmail.com> wrote:


I have implemented toString function but all that it prints all the
elements present in the hash table to be null why is it so?
import java.io.*;
import java.util.*;
import java.util.Comparator;

interface HashComparator{
          boolean isComparable(Object key);
          boolean isEqualTo(Object Key1,Object Key2);
          int hashValue(Object key);
          }

interface HashTable {
    int size();
    boolean present(int p);
    boolean isEmpty(int e);
    Object key(int k);
    Object element(int e);
    Object findElement(Object key);
    void insert(Object key,Object element);
    Object remove(Object key);
   }

class InvalidKeyException extends RuntimeException {
    InvalidKeyException(String message) {
         super(message);
    }
}

class HashTableFullException extends RuntimeException {
    HashTableFullException(String message) {
         super(message);
    }
}

   class data {
        Object key,element;

        data() {
        key = null;
        element = null;
        }

        data(Object k,Object e){
        key = k;
        element = e;
        }

        public Object key(){ return key;}
        public Object element(){ return element; }
        public void setKey(Object k) { key = k; }
        public void setElement(Object e) { element = e; }
     }

     public class MyHashTable implements HashTable {

        static data PRESENT = new data();

        int m,n;

        data[] bucket;
        Object NON_EXISTENT_KEY;

        private static HashComparator C;

        public MyHashTable(HashComparator C1){
               n = 0;
               C = C1;
               m = 200;
               bucket = new data[m];
               }

        public MyHashTable(HashComparator C1,int i){
              n = 0;
              C = C1;
              m = i;
              bucket = new data[m];
              }

         void examine(Object Key){
             try {
             if(!C.isComparable(Key)) throw new
InvalidKeyException("The key is not valid");
             }
             catch(NullPointerException n) { }
            }

        public boolean present(int x){ return (bucket[x] ==
PRESENT); }

        public boolean isEmpty(int y){ return (bucket[y] == null); }

        public Object key(int k) { return bucket[k].key();}

        public Object element(int e) { return bucket[e].element();}

        public int size() { return n; }

        int findData(Object key) throws InvalidKeyException {
            examine(key);
            int x = C.hashValue(key) % m;
            int y = x;
            do {
               if(isEmpty(x)) return -1;
               if(present(x)) x = (x+1) % m;
               else if (C.isEqualTo(key(x),key))
                    return x;
               else
                   x = (x+1) % m;
               }while(x != y);
              return -1;
           }

        public Object findElement (Object key) throws
InvalidKeyException {
               int x = findData(key);
               if(x < 0) return this.NON_EXISTENT_KEY;
               return element(x);
               }

        public void insert(Object key,Object element) throws
InvalidKeyException {
               examine(key);
               try {
               int x = C.hashValue(key) % m;
               int y = x;
               do {
                  if(isEmpty(x) || present(x)) {
                    bucket[x] = new data(key,element);
                    return;
                    }
                 x = (x+1) % m;
                 }while(x != y);
              throw new HashTableFullException("Hash table is full.
");
              }
               catch(NullPointerException n) { }
               n++;
             }

          public Object remove(Object key) throws InvalidKeyException{
                 int x = findData(key);
                 if(x < 0) return this.NON_EXISTENT_KEY;
                 Object O = element(x);
                 bucket[x] = PRESENT;
                 n--;
                 return O;
              }

        public String ConverttoString() {
        StringBuffer s = new StringBuffer();
        int i = 0;
        int elements = this.size();
        while(elements != 0) {
            s.append(" " + this.bucket[i++]);
            elements -- ;
        }
        return s.toString();
    }

          public static void main(String[] args) {
                 MyHashTable T = new MyHashTable(C);
                 try{
                 T.insert(new Integer(1),new Integer(29));
T.insert(new Integer(2),new Integer(45));
                 T.insert(new Integer(3),new Integer(37));
T.insert(new Integer(4),new Integer(99));
                 T.insert(new Integer(5),new Integer(58));
T.insert(new Integer(6),new Integer(76));
                 System.out.println(); System.out.println();
                 System.out.println("The table size is " + T.size());
                 System.out.println();
                 System.out.println("The table is "
+T.ConverttoString());
                 System.out.println();
                 }
                  catch(InvalidKeyException e) {
                        System.out.println("The key is Invalid");
                        System.out.println(e.getMessage());
                    }
                  }
}