Newsletter sign-up
View all newsletters

Enterprise Java Newsletter
Stay up to date on the latest tutorials and Java community news posted on JavaWorld

JavaWorld.com > Java Standard Edition >
JavaWorld Daily Brew
Home » Java Q&A » Core Java

Can't delete an object from an array

Submitted by rusaro on Tue, 04/21/2009 - 23:12.
Tags:

I was trying to write a phone directory program. Entries are stored in a file named directory, and each entry consists of a name and a number on adjacent lines in the file. I succeeded writing the following methods, but can't seem to get removeEntry working. I thought setting a phone entry to null will erase it from the array, but the entry doesn't get deleted from the file . Please advise.

package com.arraybaseddirectory;

/**
*
* @author Alex
* This is the class a single directory entry
* ArrayBasedPD aggregates directory entries and stores them in an array
*/
public class DirectoryEntry {
String name;
String number;

/**
* @param name The name associated with the phone number
* @param number The number coresponding to the name
*/
public DirectoryEntry(String name, String number){
this.name = name;
this.number = number;
}

/**
*
* @return
*/
public String getName(){
return name;
}

/**
*
* @param name
*/
public void setName(String name){
this.name = name;
}

/**
*
* @return
*/
public String getNumber(){
return number;
}

/**
*
* @param number
*/
public void setNumber(String number){
this.number = number;
}

@Override
public String toString(){
return name + "" + number;
}
}

package com.arraybaseddirectory;

import java.io.*;

/** This is an implementation of the PhoneDirectory interface that uses
* an array to store the data.
* */

public class ArrayBasedPD
implements PhoneDirectory {

// Data Fields

/** The initial capacity of the array */
private static final int INITIAL_CAPACITY = 4;

/** The current capacity of the array */
private int capacity = INITIAL_CAPACITY;

/** The current size of the array (number of directory entries) */
private int size = 0;

/** The array to contain the directory data */
private DirectoryEntry[] theDirectory =
new DirectoryEntry[capacity];

/** The data file that contains the directory data */
private String sourceName = null;

/** Boolean flag to indicate whether the directory was
modified since it was either loaded or saved. */
private boolean modified = false;

/** Method to load the data file.
pre: The directory storage has been created and it is empty.
If the file exists, it consists of name-number pairs
on adjacent lines.
post: The data from the file is loaded into the directory.
@param sourceName The name of the data file
*/
public void loadData(String sourceName) {
// Remember the source name.
this.sourceName = sourceName;
try {
// Create a BufferedReader for the file.
BufferedReader in = new BufferedReader(
new FileReader(sourceName));
String name;
String number;

// Read each name and number and add the entry to the array.
while ( (name = in.readLine()) != null) {
// Read name and number from successive lines.
number = in.readLine();
/*if ( (number = in.readLine()) == null) {
continue; // No number read, exit loop.
}
// Add an entry for this name and number.*/
add(name, number);
}

// Close the file.
in.close();
}
catch (FileNotFoundException ex) {
// Do nothing — no data to load.
return;
}
catch (IOException ex) {
System.err.println("Load of directory failed.");
ex.printStackTrace();
System.exit(1);
}
}

/** Add an entry or change an existing entry.
@param name The name of the person being added or changed
@param number The new number to be assigned
@return The old number or, if a new entry, null
*/
public String addOrChangeEntry(String name, String number) {
String oldNumber = null;
int index = find(name);
if (index > -1) {
oldNumber = theDirectory[index].getNumber();
theDirectory[index].setNumber(number);
}
else {
add(name, number);
}
modified = true;
return oldNumber;
}

/** Look up an entry.
@param name The name of the person
@return The number. If not in the directory, null is returned
*/
public String lookupEntry(String name) {
int index = find(name);
if (index > -1) {
return theDirectory[index].getNumber();
}
else {
return null;
}
}

/** Method to save the directory.
pre: The directory has been loaded with data.
post: Contents of directory written back to the file in the
form of name-number pairs on adjacent lines.
modified is reset to false.
*/
public void save() {
if (modified) { // If not modified, do nothing.
try {
// Create PrintWriter for the file.
PrintWriter out = new PrintWriter(
new FileWriter(sourceName));

// Write each directory entry to the file.
for (int i = 0; i < size; i++) {
// Write the name.
out.println(theDirectory[i].getName());
// Write the number.
out.println(theDirectory[i].getNumber());
}

// Close the file and reset modified.
out.close();
modified = false;
}
catch (Exception ex) {
System.err.println("Save of directory failed");
ex.printStackTrace();
System.exit(1);
}
}
}

/** Find an entry in the directory.
@param name The name to be found
@return The index of the entry with the requested name.
If the name is not in the directory, returns -1
*/
private int find(String name) {
for (int i = 0; i < size; i++) {
if (theDirectory[i].getName().equals(name)) {
return i;
}
}
return -1; // Name not found.
}

/** Add an entry to the directory.
@param name The name of the new person
@param number The number of the new person
*/
private void add(String name, String number) {
if (size >= capacity) {
reallocate();
}
theDirectory[size] = new DirectoryEntry(name, number);
size++;
}

/** Allocate a new array to hold the directory. */
private void reallocate() {
capacity *= 2;
DirectoryEntry[] newDirectory = new DirectoryEntry[capacity];
System.arraycopy(theDirectory, 0, newDirectory, 0,
theDirectory.length);
theDirectory = newDirectory;

}

public String removeEntry(String name){
int index = find(name);
String removed = theDirectory[index].getName();

theDirectory[index] = null;
return removed;
}

}