Question

Java using data structures

The objective is to create your own Hash Table class to hold a list of employees and their ID numbers. I've provided the TableEntry class which will be each data object in the hash table. The list of employees will be provided as a .txt file and must be read with the code. please create a .txt file called Employees.txt with the info provided so that the java code can read it in.

Employees.txt: (No WhiteSpace between lines)

135,John Peterman

160,Joe Divola

101,David Putty

68,Jerry Seinfeld

225,George Costanza

100,Elaine Benes

200,Cosmo Kramer

TableEntry.java:

public class TableEntry {

private int key;

private String value;

TableEntry(int key, String value) {

this.key = key;

this.value = value;

}

public int getKey() {

return key;

}

public String getValue() {

return value;

}

}

Directions:

1) Your hash table class should have an array of TableEntry objects that store the key(id number) and value(name)

2) Use the Linear probing technique to handle collisions when you add or search the table

3) You hash function code should be in its own method, NOT in your main method.

You don't have to worry about removing data from the table or keeping track of “Empty Since Start” or “Empty After Removal” buckets. Treat all empty buckets as "Empty since start".

You must have these 3 classes: Main.java, HashTable.java, TableEntry.java

Flow of the main program:

Create an instance of your hash table class in the main class.

Read in the Employees.txt file and store the names and ID numbers in your hash table using the SIMPLE modulo operator (%) hash function: "key%N" where N is the size of your array.

After you stored all the data in the table, print out all the employee names and their corresponding id numbers.

Pick a random employee's ID number and then search for them in the hash table and retrieve their name, print it to the screen.

must read in data from text file Employees.txt (No Whitespace between entries, just next line between entries)

Answer 1

1) tableentry.java

package customhashtable;

public class TableEntry {
  
   private int key;
   private String value;

   TableEntry(int key, String value) {
       this.key = key;
       this.value = value;
   }

   public int getKey() {
       return key;
   }

   public String getValue() {
       return value;
   }

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

2) hashtable.java

package customhashtable;

public class HashTable {

   private int currentSize, maxSize;
   private TableEntry[] entries;

   /** Constrctor **/
   HashTable(int capacity) {
       this.maxSize = capacity;
       currentSize = 0;
       entries = new TableEntry[maxSize];
   }

   /** Function to clear hash table **/
   public void makeEmpty()

   {
       currentSize = 0;
       entries = new TableEntry[maxSize];

   }

   /** Function to get size of hash table **/
   public int getSize() {
       return currentSize;
   }

   /** Function to check if hash table is full **/
   public boolean isFull()

   {
       return currentSize == maxSize;
   }

   /** Function to check if hash table is empty **/
   public boolean isEmpty() {
       return getSize() == 0;
   }

   /** Function to check if hash table contains a key **/
   public boolean contains(int key)

   {
       return get(key) != null;
   }

   /** Function to insert key-value pair **/
   public void insert(int key, String value)

   {
       int tmp = key % maxSize;
       int i = tmp;
      
       do {
           if (entries[i] == null) {
               entries[i] = new TableEntry(key, value);
               currentSize++;
               return;
           }

           if (entries[i].getKey() == key) {
               entries[i].setValue(value);
           }

           i = (i + 1) % maxSize;

       } while (i != tmp);

   }

   /** Function to get value for a given key **/
   public String get(int key) {

       int i = key % maxSize;

       while (entries[i] != null) {
           if (entries[i].getKey() == key)
               return entries[i].getValue();

           i = (i + 1) % maxSize;
       }
       return null;
   }

   /** Function to remove key and its value **/

   public void remove(int key)

   {

       if (!contains(key))
           return;
       /** find position key and delete **/

       int i = key % maxSize ;

       while (!(key==entries[i].getKey()))
           i = (i + 1) % maxSize;
      
       entries[i] = null;

       currentSize--;

   }

  
   /** Function to print HashTable **/

   public void printHashTable() {
       System.out.println("\nHash Table: ");

       for (int i=0;i<maxSize;i++)
           if (entries[i] != null)
               System.out.println(entries[i].getKey() + " " + entries[i].getValue());
       System.out.println();

   }

}

3) main.java

package customhashtable;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class Main {

   public static void main(String[] args)

   {

       Scanner sc = new Scanner(System.in);

       System.out.println("Hash Table Test\n\n");

       System.out.println("Enter size");

       // creating hashtable with given size
       HashTable htable = new HashTable(sc.nextInt());
      
       // File Properties
      
       BufferedReader in;
       String file="employees.txt";
      
      
       char ch;

       /** Perform HashTable operations **/

       do

       {

           System.out.println("\nHash Table Operations\n");

           System.out.println("0. access new data from file");
          
           System.out.println("1. insert ");

           System.out.println("2. remove");

           System.out.println("3. get");

           System.out.println("4. clear");

           System.out.println("5. size");

           int choice = sc.nextInt();

           switch (choice)

           {
           case 0: {
              
                  try { //Accessing file information
                          in = new BufferedReader(new FileReader(file));
                        String str;
                        int count=0;
                      
                        //Counting number of entries
                        while ((str = in.readLine())!= null) {
                           count++;
                        }
                      
                        in.close();
                      
                        //Reopening file to start from begining
                        in = new BufferedReader(new FileReader(file));
                      
                        //creating hashtable base on count value
                        htable = new HashTable(count);
                      
                        while ((str = in.readLine())!= null) {
                            String[] linearray=str.split(",");
                          
                            int key=Integer.parseInt(linearray[0].trim());
                            String value= linearray[1].trim();
                         
                            htable.insert(key, value);
                        }
                 
                        in.close();
                    } catch (IOException e) {
                        System.out.println("File Read Error");
                        break;
                    }
                  System.out.println("Table created..");
                  break;
           }
          
          
           case 1: {
              
               if(htable.isFull()){
                   System.out.println("List is Full...");
                   break;
               }

               int key;
               String value;
               System.out.println("Enter key : ");
               key = sc.nextInt();

               System.out.println("Enter value : ");
               value = sc.next();

               htable.insert(key, value);
              
               System.out.println("inserted...");
               break;

           }

           case 2: {
              
               System.out.println("Enter key");
               htable.remove(sc.nextInt());
               System.out.println("removed...");
               break;

           }

           case 3:{
              
               System.out.println("Enter key");
               System.out.println("Value = " + htable.get(sc.nextInt()));
              
               break;
           }
          
           case 4:
           {
               htable.makeEmpty();
               System.out.println("Hash Table Cleared\n");
               break;
           }
           case 5:
           {
               System.out.println("Size = " + htable.getSize());
               break;
           }
          
           default:
           {
               System.out.println("Wrong Entry \n ");
               break;
           }
           }

           /** Display hash table **/

           htable.printHashTable();

           System.out.println("\nDo you want to continue (Type y or n) \n");

           ch = sc.next().charAt(0);

       } while (ch == 'Y' || ch == 'y');
   }
}