By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
464,372 Members | 1,223 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 464,372 IT Pros & Developers. It's quick & easy.

Phone directory remove directory

P: 55
I am trying to write a code for a Phone Directory program. This program is suppose to allow the user to enter a name or directory and then program can either add, save or even delete an entry. Also this program has more then one class and also uses an interface. Right now I am working on
ArrayBasedPD class. I am trying to write a code for the remove method (line 158) that allows the user to enter a name, once the program sees that the name is in the directory, it deletes it. The way I tried to do it was simply do the opposite of the Add method, instead of incrementing the size of the array, I would decrement it, because I would believe that when decrementing the size that an entry is being deleted.
This may be kinda confusinf to understand since their are more Classes for this program, such as the Class phone directory is an interface that is being implemented by theArrayBasedPD class (this one).

Expand|Select|Wrap|Line Numbers
  1. package CH01;
  2.  
  3. import java.io.*;
  4.  
  5.  /** This is an implementation of the PhoneDirectory interface that uses
  6.   *   an array to store the data.
  7.   *   @author Koffman & Wolfgang
  8.   */
  9.  
  10. public class ArrayBasedPD implements PhoneDirectory {
  11.  
  12.   // Data Fields
  13.  
  14.   /** The initial capacity of the array */
  15.   private static final int INITIAL_CAPACITY = 100;
  16.  
  17.   /** The current capacity of the array */
  18.   private int capacity = INITIAL_CAPACITY;
  19.  
  20.   /** The current size of the array (number of directory entries) */
  21.   private int size = 0;
  22.  
  23.   /** The array to contain the directory data */
  24.   private DirectoryEntry[] theDirectory =
  25.       new DirectoryEntry[capacity];
  26.  
  27.   /** The data file that contains the directory data */
  28.   private String sourceName = null;
  29.  
  30.   /** Boolean flag to indicate whether the directory was
  31.       modified since it was either loaded or saved. */
  32.   private boolean modified = false;
  33.  
  34.   /** Method to load the data file.
  35.        pre:  The directory storage has been created and it is empty.
  36.         If the file exists, it consists of name-number pairs
  37.         on adjacent lines.
  38.        post: The data from the file is loaded into the directory.
  39.        @param sourceName The name of the data file
  40.    */
  41.   public void loadData(String sourceName) {
  42.     // Remember the source name.
  43.     this.sourceName = sourceName;
  44.     try {
  45.       // Create a BufferedReader for the file.
  46.       BufferedReader in = new BufferedReader(
  47.           new FileReader(sourceName));
  48.       String name;
  49.       String number;
  50.  
  51.       // Read each name and number and add the entry to the array.
  52.       while ( (name = in.readLine()) != null) {
  53.         // Read name and number from successive lines.
  54.         if ( (number = in.readLine()) == null) {
  55.           break; // No number read, exit loop.
  56.         }
  57.         // Add an entry for this name and number.
  58.         add(name, number);
  59.       }
  60.  
  61.       // Close the file.
  62.       in.close();
  63.     }
  64.     catch (FileNotFoundException ex) {
  65.       // Do nothing — no data to load.
  66.       return;
  67.     }
  68.     catch (IOException ex) {
  69.       System.err.println("Load of directory failed.");
  70.       ex.printStackTrace();
  71.       System.exit(1);
  72.     }
  73.   }
  74.  
  75.   /** Add an entry or change an existing entry.
  76.       @param name The name of the person being added or changed
  77.       @param number The new number to be assigned
  78.       @return The old number or, if a new entry, null
  79.    */
  80.   public String addOrChangeEntry(String name, String number) {
  81.     String oldNumber = null;
  82.     int index = find(name);
  83.     if (index > -1) {
  84.       oldNumber = theDirectory[index].getNumber();
  85.       theDirectory[index].setNumber(number);
  86.     }
  87.     else {
  88.       add(name, number);
  89.     }
  90.     modified = true;
  91.     return oldNumber;
  92.   }
  93.  
  94.   /** Look up an entry.
  95.     @param name The name of the person
  96.     @return The number. If not in the directory, null is returned
  97.    */
  98.   public String lookupEntry(String name) {
  99.     int index = find(name);
  100.     if (index > -1) {
  101.       return theDirectory[index].getNumber();
  102.     }
  103.     else {
  104.       return null;
  105.     }
  106.   }
  107.  
  108.   /** Method to save the directory.
  109.       pre:  The directory has been loaded with data.
  110.       post: Contents of directory written back to the file in the
  111.             form of name-number pairs on adjacent lines.
  112.             modified is reset to false.
  113.    */
  114.   public void save() {
  115.     if (modified) { // If not modified, do nothing.
  116.       try {
  117.         // Create PrintWriter for the file.
  118.         PrintWriter out = new PrintWriter(
  119.             new FileWriter(sourceName));
  120.  
  121.         // Write each directory entry to the file.
  122.         for (int i = 0; i < size; i++) {
  123.           // Write the name.
  124.           out.println(theDirectory[i].getName());
  125.           // Write the number.
  126.           out.println(theDirectory[i].getNumber());
  127.         }
  128.  
  129.         // Close the file and reset modified.
  130.         out.close();
  131.         modified = false;
  132.       }
  133.       catch (Exception ex) {
  134.         System.err.println("Save of directory failed");
  135.         ex.printStackTrace();
  136.         System.exit(1);
  137.       }
  138.     }
  139.   }
  140.  
  141.   /** Find an entry in the directory.
  142.       @param name The name to be found
  143.       @return The index of the entry with the requested name.
  144.               If the name is not in the directory, returns -1
  145.    */
  146.   private int find(String name) {
  147.     for (int i = 0; i < size; i++) {
  148.       if (theDirectory[i].getName().equals(name)) {
  149.         return i;
  150.       }
  151.     }
  152.     return -1; // Name not found.
  153.   }
  154.   /**remove Entry
  155.    * @param name The name of the person to be deleted
  156.    * 
  157.    */
  158.      public void remove(String name) {
  159.      int i = find(name);
  160.       if(i <= -1)
  161.      System.out.println("Entry not found; cannot delete!");
  162.      else
  163.          theDirectory[size] = new DirectoryEntry(name);
  164.     size--; 
  165.  
  166.     modified = true;
  167.   }
  168.  
  169.  
  170.  
  171.   /** Add an entry to the directory.
  172.       @param name The name of the new person
  173.       @param number The number of the new person
  174.    */
  175.   private void add(String name, String number) {
  176.     if (size >= capacity) {
  177.       reallocate();
  178.     }
  179.     theDirectory[size] = new DirectoryEntry(name, number);
  180.     size++;
  181.   }
  182.  
  183.   /** Allocate a new array to hold the directory. */
  184.   private void reallocate() {
  185.     capacity *= 2;
  186.     DirectoryEntry[] newDirectory = new DirectoryEntry[capacity];
  187.     System.arraycopy(theDirectory, 0, newDirectory, 0,
  188.                      theDirectory.length);
  189.     theDirectory = newDirectory;
  190.   }
  191.  
  192.  
  193. }
Sep 10 '09 #1
Share this Question
Share on Google+
6 Replies

10K+
P: 13,262
Looks like you got some code from somewhere that you don't really understand what it does.
Better start with Sun's Java tutorial.
Sep 11 '09 #2

Expert 10K+
P: 11,448
That remove() method doesn't make sense to me:

Expand|Select|Wrap|Line Numbers
  1.    public void remove(String name) { 
  2.      int i = find(name); 
  3.       if(i <= -1) 
  4.      System.out.println("Entry not found; cannot delete!"); 
  5.      else 
  6.          theDirectory[size] = new DirectoryEntry(name); 
  7.     size--;  
  8.  
  9.     modified = true; 
  10.   } 
  11.  
I read it as: try to find that name; if not found print a message otherwise make a new entry? and decrement the size of it all?

kind regards,

Jos
Sep 11 '09 #3

P: 55
Ok if that is what is wrong, then How can I make it delete the entry? I thought decrementing the size of the array would be deleting an entry out of the array. Or do I just decrement the size? Im confused.
Sep 11 '09 #4

Expert 10K+
P: 11,448
@falconsx23
For starters: you can't resize an array once you have instantiated one. Better use an ArrayList, you can delete any element from it given the index value of the element.

kind regards,

Jos
Sep 11 '09 #5

P: 55
Well besides making an array list, is there anyway that I can remove an entry. I was thinking of another idea where I could overwrite an element in the array. Like it searches for a name, once the array is found, it takes the name before the found name and replaces moves it up. For instance:

Bob, Ray, Jill

Ray was found, but the remove method allows Bob to replace Ray, thus making it

Bob, Bob, Jill
Sep 11 '09 #6

Expert 10K+
P: 11,448
@falconsx23
The ArrayList class object can do that for you with its 'remove()' method; read the API documentation.

kind regards,

Jos
Sep 12 '09 #7

Post your reply

Sign in to post your reply or Sign up for a free account.