ChengJade12.java

import java.lang.reflect.Array;
import java.util.NoSuchElementException;
import java.util.Scanner;
 
/**
 * This is an implementation of Assignment 12.
 * 
 * @author     Cheng Yu
 * @assignment ICS211 Homework TA12
 * @date       Apr 20, 2010
 * @bugs       None
 */
public class ChengJade12 {
 
  /**
   * The main entry point of the program.
   * 
   * @param args The command line arguments (not used).
   */
  public static void main(final String[] args) {
    final PhoneBook book = new PhoneBook();
    final Scanner scanner = new Scanner(System.in);
 
    // Loop until the user selects quit, but always show the menu of options.
    try {
      while (true) {
 
        // Display the menu.
        System.out.println("\nChoose one of the four options:\n");
        System.out.println("  1) Type 'quit' to exit the program.");
        System.out.println("  2) Type 'insert' to add a new contact.");
        System.out.println("  3) Type 'delete' to delete a contact.");
        System.out.println("  4) Type 'display' to show the phone book.");
        System.out.println("  5) Type a name to show a phone number.");
        System.out.print("\nYour option: ");
        final String input = scanner.nextLine();
 
        // Check for the quit command.
        if (input.equalsIgnoreCase("quit"))
          break;
 
        // Check for the insert command.
        if (input.equalsIgnoreCase("insert")) {
          System.out.print("\nPlease enter the name to add: ");
          final String name = scanner.nextLine();
          System.out.print("Please enter phone number:    ");
          final String number = scanner.nextLine();
 
          if (!validPhoneNumber(number))
            System.out.println("\nWarning: '" + number
                + "' does not look like a valid phone number.");
 
          // It is unlikely but possible that two different names will produce
          // the same hash code, but if they do it will cause a failure in this
          // implementation of the hash table.
          try {
            book.add(name, number);
          } catch (final RuntimeException e) {
            System.err.println("\nError: Cannot add '" + name
                + "' because another entry with a different\nname exists "
                + "in the hash table and produces the same hash code.");
            continue;
          }
 
          System.out.println("\nInserted '" + name + "' with phone number '"
              + number + "'.");
          continue;
        }
 
        // Check for the delete command.
        if (input.equalsIgnoreCase("delete")) {
          System.out.print("\nPlease enter the name to remove: ");
          final String name = scanner.nextLine();
          try {
            book.remove(name);
          } catch (final NoSuchElementException e) {
            System.out.println("\nThe name '" + name + "' does not exist.");
            continue;
          }
          System.out.println("\nRemoved '" + name + "' from the phone book.");
          continue;
        }
 
        // Check for the display command.
        if (input.equalsIgnoreCase("display")) {
          System.out.println(String.format("\n%1$-10s%2$-20s%3$s", "#", "Name",
              "Phone Number"));
          System.out.print(book);
          continue;
        }
 
        // For all other cases, treat the input as a name to search for.
        final String number;
        try {
          number = book.getPhoneNumber(input);
        } catch (final NoSuchElementException e) {
          System.out.println("\nThe name '" + input + "' does not exist.");
          continue;
        }
 
        System.out.println("\n" + input + "'s phone number is " + number + ".");
      }
    } catch (final NoSuchElementException e) {
      // The user has canceled the program (probably with Ctrl-C. Exit normally.
    }
 
    System.exit(0);
  }
 
 
  /**
   * This method returns true if the specified phone number matches a typical
   * phone number pattern: "[#-[###-]]###-####".
   * 
   * @param number The phone number.
   * @return True indicates the phone number is valid looking.
   */
  private static boolean validPhoneNumber(final String number) {
    assert number != null;
    return number.matches("(\\d-)?(\\d{3}-)?\\d{3}-\\d{4}");
  }
}
 
/**
 * This class implements a generic hash table. The items of the hash table must
 * be comparable with each other.
 */
class HashTable<T extends Comparable<T>> {
  private T[] myTable = newArray(3);
 
  /**
   * This method adds an item to the hash table. In the event of a collision,
   * the hash table is resized. If the item already exists in the hash table,
   * then it is replaced. The item cannot be null.
   * 
   * @param o The item to add.
   */
  public void add(final T value) {
    if (value == null)
      throw new NullPointerException("value");
    final int index = getIndex(value, myTable.length);
    if (myTable[index] == null || myTable[index].compareTo(value) == 0) {
      myTable[index] = value;
      return;
    }
    // If two different names return the same hash code, there is no possible
    // way to rehash the table. For example, "2<" and "0z" return the same
    // hash code. If these two strings were added to the hash table, then the
    // rehash method would fail with a stack overflow due to infinite recursion.
    // Instead of failing in this way, we handle the condition more gracefully.
    if (myTable[index].hashCode() == value.hashCode())
      throw new RuntimeException();
    rehash(myTable.length * 2 + 1);
    add(value);
  }
 
 
  /**
   * This method searches for an item in the hash table. If the item is found,
   * the item is returned from the hash table. If the item is not found, then
   * null is returned.
   * 
   * @param o The item to find.
   * @return The item from the hash table or null if the item is not found.
   */
  public T find(final T value) {
    if (value == null)
      throw new NullPointerException("value");
    final int index = getIndex(value, myTable.length);
    if (myTable[index] == null || myTable[index].compareTo(value) != 0)
      return null;
    return myTable[index];
  }
 
 
  /**
   * This method removes an item from the hash table and returns true if
   * successful. If the item is not found, the method returns false.
   * 
   * @param o The item.
   * @return True indicates the item was removed.
   */
  public boolean remove(final T value) {
    if (value == null)
      throw new NullPointerException("value");
    final int index = getIndex(value, myTable.length);
    if (myTable[index] == null || myTable[index].compareTo(value) != 0)
      return false;
    myTable[index] = null;
    return true;
  }
 
 
  /**
   * This method returns the string representation of the class.
   * 
   * @return The string representation of the class.
   */
  @Override
    public String toString() {
    final StringBuilder builder = new StringBuilder();
    int j = 0;
    for (final T element : myTable)
      if (element != null)
        builder.append(String.format("%1$-10s%2$s\n", Integer.valueOf(++j),
            element));
    builder.append('\n' + "The current table size is: " + myTable.length + '\n');
    return builder.toString();
  }
 
 
  /**
   * This method returns a hash code index for the specified object. The value
   * returned is some number between zero and one less than the specified size.
   * 
   * @param o The object.
   * @param tableSize The table size.
   * @return The hash code index.
   */
  private int getIndex(final T value, final int tableSize) {
    assert value != null;
    assert tableSize > 0;
    return Math.abs(value.hashCode()) % tableSize;
  }
 
 
  /**
   * Creates and returns an array of a specified length for the generic type.
   * 
   * @param length The length of the array.
   * @return A new array of the generic type.
   */
  @SuppressWarnings("unchecked")
  private T[] newArray(final int length) {
    assert length >= 0;
    return (T[])Array.newInstance(Comparable.class, length);
  }
 
 
  /**
   * This method rehashes the hash table for a new size. If there are collisions
   * while rehashing the table, then the method executes recursively with a
   * larger size.
   * 
   * @param newSize The new size of the hash table.
   */
  private void rehash(final int newSize) {
    assert newSize > myTable.length;
    final T[] newTable = newArray(newSize);
    for (final T value : myTable) {
      if (value == null)
        continue;
      final int index = getIndex(value, newSize);
      if (newTable[index] == null) {
        newTable[index] = value;
        continue;
      }
      rehash(newSize * 2 + 1);
      return;
    }
    myTable = newTable;
  }
}
 
/**
 * This class implements information that is entered into the telephone book.
 */
class PersonInfo implements Comparable<PersonInfo> {
  private final String myName;
  private final String myNumber;
 
 
  /**
   * This method compares two instances of class. The comparison is based only
   * on the name and not the number.
   * 
   * @return 1 if greater, 0 if equal, and -1 if less than the specified value.
   */
  public int compareTo(final PersonInfo person) {
    return person == null ? 1 : myName.compareToIgnoreCase(person.getName());
  }
 
 
  /**
   * This constructor initializes the class data so that it is suitable for
   * searching for entries. The number is initializes to zero.
   * 
   * @param name The name of the entry.
   */
  public PersonInfo(final String name) {
    this(name, "");
  }
 
 
  /**
   * This constructor initializes the class data.
   * 
   * @param name The name of the entry.
   * @param number The phone number of the entry.
   */
  public PersonInfo(final String name, final String number) {
    if (name == null)
      throw new NullPointerException("name");
    if (number == null)
      throw new NullPointerException("number");
    myName = name;
    myNumber = number;
  }
 
 
  /**
   * This method returns the name.
   * 
   * @return The name.
   */
  public String getName() {
    return myName;
  }
 
 
  /**
   * This method returns the number.
   * 
   * @return The number.
   */
  public String getNumber() {
    return myNumber;
  }
 
 
  /**
   * This method returns the hash code for the class. The code is based only on
   * the name and not the number.
   * 
   * @return The hash code.
   */
  @Override
  public int hashCode() {
    return myName.hashCode();
  }
 
 
  /**
   * This method returns the string representation of the class.
   * 
   * @return The string representation of the class.
   */
  @Override
  public String toString() {
    return String.format("%1$-20s%2$s", myName, myNumber);
  }
}
 
/**
 * This class implements a phone book.
 */
class PhoneBook {
  private final HashTable<PersonInfo> book = new HashTable<PersonInfo>();
 
  /**
   * This method adds an item to the phone book.
   * 
   * @param name The name to add.
   * @param number The number to add.
   */
  public void add(final String name, final String number) {
    if (name == null)
      throw new NullPointerException("name");
    book.add(new PersonInfo(name, number));
  }
 
 
  /**
   * This method searches for an item in the telephone book. If the item is
   * found, then the phone number is returned. If the item is not found, then
   * NoSuchElementException is thrown.
   * 
   * @param name The name of the item to find.
   * @return The phone number or null if the item is not found.
   * @throws NoSuchElementException
   */
  public String getPhoneNumber(final String name) {
    if (name == null)
      throw new NullPointerException("name");
    final PersonInfo entryFound = book.find(new PersonInfo(name));
    if (entryFound == null)
      throw new NoSuchElementException();
    return entryFound.getNumber();
  }
 
 
  /**
   * This method removes an item (based on a name) from the phone book.
   * 
   * @param name The name of the item to remove.
   * @throws NoSuchElementException
   */
  public void remove(final String name) {
    if (name == null)
      throw new NullPointerException("name");
    if (!book.remove(new PersonInfo(name)))
      throw new NoSuchElementException();
  }
 
 
  /**
   * This method returns the string representation of the class.
   * 
   * @return The string representation of the class.
   */
  @Override
  public String toString() {
    return book.toString();
  }
}
 
Valid HTML 4.01 Valid CSS