Can't write collection back to disk

[Paul Immoos]

I am doing a server/client setup and this is the server code. Here is wherethe info is loaded, it comes from the employees.txt:

  // Read data from disk and load the collection.
 
    try {
 
      FileReader fr = new FileReader(path);
      BufferedReader br = new BufferedReader(fr);
      String line = br.readLine();
      while (line != null) {
        StringTokenizer parser = new StringTokenizer(line, ",");
          emp = new Employee(Integer.parseInt(parser.nextToken()), (parser.nextToken()));
          employees.put(new Integer(emp.getNumber()), emp); 
        while (parser.hasMoreTokens()) {
          
          threads.add(parser.nextToken());
 
        }
      line = br.readLine();
      }
      message.append("Collection loaded" + "\n");
    }
    catch (IOException err) {
      System.out.println(err.getMessage());
    }  

then here is teh code for writing the collection back to disk in sequence to udpate any changes teh client made.

 //CODE TO WRITE THE COLLECTION'S DATA BACK TO DISK IN
      // ASCENDING KEY SEQUENCE GOES HERE 
       
       
      FileWriter fw = new FileWriter(path);
      BufferedWriter bw = new BufferedWriter(fw);
      while(p.hasNext());
      emp = (Employee)employees.get(p.next());
      bw.write(emp.getNumber() +"," + emp.getName());
      bw.close();
 
      }
      catch (IOException err) {
        message.append(err.getMessage() + "\n");
      }
      frame.dispose();
      System.exit(0);
    }   

once the Server is compiled and I run it, the data is then deleted out of my employees.txt. I know i am missing something, i just don't have a clue what it is





BTW here is the all the code for the program:

   // Import statements make it possible to reference required packaged code.
 
import java.io.*;
import java.net.*;
import java.util.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
 
// This class defines a server that allows connection of multiple clients
// to access a shared file of employee data.
// ---- Written by: Jon Huhtala
// ---- Modified by: Paul Immoos
 
public class Server {
 
  // Variables
 
  String path = "e:/drive/java/project03/employees.txt";      // Path of disk file
  Map employees = new TreeMap();              // The employee collection
  Employee emp;                               // The current Employee object
  int port = 7000;                            // Port number
  int loginNumber = 0;                        // For counting logins
  ArrayList threads;                          // For storing thread references
  JPanel panel;                               // Component panel
  TextArea message;                           // For Scrolling message area
  JFrame frame;                               // Reference for main window
  JButton exit;                               // EXIT button
 
  // Main method to create a Server object and begin its processing.
 
  public static void main(String[] args) {
    new Server().go();
  }
 
  // This method builds the server GUI, reads data from disk and loads
  // it into the collection, establish a port, and receive client logins.
 
  public void go() {
 
    // Build the GUI.
 
    frame = new JFrame("Server");
    frame.setSize(350, 275);
    frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
    panel = new JPanel();
    panel.setLayout(new FlowLayout());
    panel.add(new JLabel("Server Status and Messages"));
    message = new TextArea("", 10, 40, TextArea.SCROLLBARS_VERTICAL_ONLY);
    message.setBackground(Color.black);
    message.setForeground(Color.yellow);
    panel.add(message);
    exit = new JButton("EXIT");
    exit.addActionListener(new ExitListener());
    panel.add(exit);
    frame.getContentPane().add(panel);
    frame.setVisible(true);
 
    // Read data from disk and load the collection.
 
    try {
 
      FileReader fr = new FileReader(path);
      BufferedReader br = new BufferedReader(fr);
      String line = br.readLine();
      while (line != null) {
        StringTokenizer parser = new StringTokenizer(line, ",");
          emp = new Employee(Integer.parseInt(parser.nextToken()), (parser.nextToken()));
          employees.put(new Integer(emp.getNumber()), emp); 
        while (parser.hasMoreTokens()) {
          
          threads.add(parser.nextToken());
 
        }
      line = br.readLine();
      }
      message.append("Collection loaded" + "\n");
    }
    catch (IOException err) {
      System.out.println(err.getMessage());
    }
 
    // Establish a port and accept client logins.
 
    try {
      ServerSocket ss = new ServerSocket(port);
      message.append("Server active" + "\n");
      message.append("Address: " + InetAddress.getLocalHost() + "\n");
      message.append("Port: " + port + "\n");
      threads = new ArrayList();
      while (true) {
        Socket s = ss.accept();
 
        // Create a thread to process requests from the client, add it
        // to the list of threads, and start its processing.
 
        ServerThread thread = new ServerThread(s, loginNumber);
        threads.add(thread);
        thread.start();
        loginNumber++;
      }
    }
    catch(IOException err) {
      message.append(err.getMessage() + "\n");
    }
  }
 
  // This inner class defines an action listener for the exit button.
 
  class ExitListener implements ActionListener {
 
    // When the button is clicked, all active threads are killed, data
    // is written back to disk from the collection in ascending employee
    // number order, and the server is shutdown.
 
    public void actionPerformed(ActionEvent e) {
      for (int i = 0; i < threads.size(); i++) {
        ((ServerThread)threads.get(i)).kill();
        threads.remove(i);
      }
      Iterator p = employees.keySet().iterator();
      try {
 
      // YOUR CODE TO WRITE THE COLLECTION'S DATA BACK TO DISK IN
      // ASCENDING KEY SEQUENCE GOES HERE 
       
       
      FileWriter fw = new FileWriter(path);
      BufferedWriter bw = new BufferedWriter(fw);
      while(p.hasNext());
      emp = (Employee)employees.get(p.next());
      bw.write(emp.getNumber() +"," + emp.getName());
      bw.close();
 
      }
      catch (IOException err) {
        message.append(err.getMessage() + "\n");
      }
      frame.dispose();
      System.exit(0);
    }
  }
 
  // This inner class encapsulates the thread processing for a single client.
 
  class ServerThread extends Thread {
 
    // Variables
 
    boolean alive;                  // For continuing thread processing
    int threadNum;                  // For holding assigned thread number
    Socket s;                       // Reference for the thread's Socket
    ObjectOutputStream toClient;    // For writing objects to the client
    ObjectInputStream fromClient;   // For reading objects from the client
 
    // This constructor initializes the ServerThread object, creates
    // object streams for communicating with the client, and sends the
    // client its Integer thread number.
 
    public ServerThread(Socket mySocket, int myThreadNum) {
      s = mySocket;
      threadNum = myThreadNum;
      try {
        toClient = new ObjectOutputStream(s.getOutputStream());
        fromClient = new ObjectInputStream(s.getInputStream());
        toClient.writeObject(new Integer(threadNum));
        toClient.flush();
        message.append("Thread " + threadNum + ": Connected" + "\n");
      }
      catch(IOException err) {
        message.append("Thread " + threadNum + ": " + err.getMessage() + "\n");
      }
    }
 
    // This method defines thread processing with the client. The thread is
    // marked as being alive, then it loops to handle client requests until
    // it is killed.
 
    public void run() {
      alive = true;
      while (alive) {
        try {
          String request = (String)fromClient.readObject();
 
          // Processing for a "FIND" request.
 
          if (request.equals("FIND")) {
 
            // Read the employee number from the client. If it matches that
            // of an existing employee, get the Employee object from the
            // collection and send it to the client. Otherwise, send a "dummy"
            // Employee object to indicate that the requested employee was
            // not found.
 
            Integer empNum = (Integer)fromClient.readObject();
            if (employees.containsKey(empNum)) {
              emp = (Employee)employees.get(empNum);
              toClient.writeObject(emp);
              toClient.flush();
              message.append("Thread " + threadNum + ": FOUND employee " +
                             emp.getNumber() + "\n");
            }
            else {
              toClient.writeObject(new Employee(0, ""));
              toClient.flush();
              message.append("Thread " + threadNum +
                             ": DID NOT FIND employee " +
                             empNum.intValue() + "\n");
            }
          }
 
          // Processing for an "ADD" request.
 
          else if (request.equals("ADD")) {
 
            // Read the Employee object from the client. If an employee
            // with a matching employee number already exists, send an error
            // String to the client. Otherwise, put the Employee object into the
            // collection and send a verification String to the client.
 
            emp = (Employee)fromClient.readObject();
            if (safeUpdate() == false) {
              toClient.writeObject("NOT ADDED");
              toClient.flush();
              message.append("Thread " + threadNum +
                             ": DID NOT ADD employee " +
                             emp.getNumber() + "\n");
            }
            else {
              toClient.writeObject("ADDED");
              toClient.flush();
              message.append("Thread " + threadNum + ": ADDED employee " +
                             emp.getNumber() + "\n");
            }
          }
 
          // Processing for a "DISCONNECT" request.
 
          else if (request.equals("DISCONNECT")) {
            alive = false;
            message.append("Thread " + threadNum + ": DISCONNECTING" + "\n");
          }
 
          // Processing for an invalid request. The thread is killed due to
          // the difficulty of re-synchronizing client communications.
 
          else {
            alive = false;
            message.append("Thread " + threadNum +
                           ": INVALID: " + request + "\n");
          }
        }
        catch (Exception err) {
          alive = false;
          message.append("Thread " + threadNum + ": " +
                         err.getMessage() + "\n");
        }
      }
 
      // Close the object streams as thread processing ends.
 
      try {
        fromClient.close();
        toClient.close();
        message.append("Thread " + threadNum + ": DISCONNECTED" + "\n");
      }
      catch (Exception err) {
        message.append("Thread " + threadNum + ": " + err.getMessage() + "\n");
      }
    }
 
    // This method can be called to kill the thread's processing loop.
 
    public void kill() {
      alive = false;
    }
 
    // This method can be called to safely update the collection in a
    // multithreaded environment.
 
    public synchronized boolean safeUpdate() {    // CHANGE WHERE SHOWN
      if (employees.containsKey(new Integer(emp.getNumber()))) {
        return false;
      }
      else {
        employees.put(new Integer(emp.getNumber()), emp);
        return true;
      }
    }
  }
}
 
// This class encapsulates the data and processing of an employee.
// ---- Written by: Jon Huhtala
 
class Employee implements Serializable{    // CHANGE WHERE SHOWN
 
  // Instance variables
 
  private int number;
  private String name;
 
  // This constructor will initialize employee data to values supplied by
  // the caller. No editing is performed (let's hope they get it right).
 
  public Employee(int iNumber, String iName) {
    number = iNumber;
    name = iName;
  }
 
  // These "getter" methods will return the corresponding employee data.
 
  public int getNumber() {
    return number;
  }
  public String getName() {
    return name;
  }
} 
 

[Jeff Albertson]

Your writing loop has an empty body:

while(p.hasNext()); //<-- note semicolon