Random Access File not working, Need Help!!!!

Question

I am having trouble creating and displaying a Random Access File for hardware tools. I have included the code below in eight files:
// Exercise 14.11: HardwareRecord.java
package org.egan; // packaged for reuse
public class HardwareRecord
  private int recordNumber;
  private String toolName;
  private int quantity;
  private double cost;
  // no-argument constructor calls other constructor with default values
  public HardwareRecord()
    this(0,"",0,0.0); // call four-argument constructor
  } // end no-argument HardwareRecord constructor
  // initialize a record
  public HardwareRecord(int number, String tool, int amount, double price)
    setRecordNumber(number);
    setToolName(tool);
    setQuantity(amount);
    setCost(price);
  } // end four-argument HardwareRecord constructor
  // set record number
  public void setRecordNumber(int number)
    recordNumber = number;
  } // end method setRecordNumber
  // get record number
  public int getRecordNumber()
    return recordNumber;
  } // end method getRecordNumber
  // set tool name
  public void setToolName(String tool)
    toolName = tool;
  } // end method setToolName
  // get tool name
  public String getToolName()
    return toolName;
  } // end method getToolName
  // set quantity
  public void setQuantity(int amount)
    quantity = amount;
  } // end method setQuantity
  // get quantity
  public int getQuantity()
    return quantity;
  } // end method getQuantity
  // set cost
  public void setCost(double price)
    cost = price;
  } // end method setCost
  // get cost
  public double getCost()
    return cost;
  } // end method getCost
} // end class HardwareRecord------------------------------------------------------------------------------------------------
// Exercise 14.11: RandomAccessHardwareRecord.java
// Subclass of HardwareRecord for random-access file programs.
package org.egan; // package for reuse
import java.io.RandomAccessFile;
import java.io.IOException;
public class RandomAccessHardwareRecord extends HardwareRecord
  public static final int SIZE = 72;
  // no-argument constructor calls other constructor with default values
  public RandomAccessHardwareRecord()
    this(0,"",0,0.0);
  } // end no-argument RandomAccessHardwareRecord constructor
  // initialize a RandomAccessHardwareRecord
  public RandomAccessHardwareRecord(int number, String tool, int amount, double price)
    super(number,tool,amount,price);
  } // end four-argument RandomAccessHardwareRecord constructor
  // read a record from a specified RandomAccessFile
  public void read(RandomAccessFile file) throws IOException
    setRecordNumber(file.readInt());
    setToolName(readName(file));
    setQuantity(file.readInt());
    setCost(file.readDouble());
  } // end method read
  // ensure that name is proper length
  private String readName(RandomAccessFile file) throws IOException
    char name[] = new char[15], temp;
    for(int count = 0; count < name.length; count++)
      temp = file.readChar();
      name[count] = temp;
    } // end for
    return new String(name).replace('\0',' ');
  } // end method readName
  // write a record to specified RandomAccessFile
  public void write(RandomAccessFile file) throws IOException
    file.writeInt(getRecordNumber());
    writeName(file, getToolName());
    file.writeInt(getQuantity());
    file.writeDouble(getCost());
  } // end method write
  // write a name to file; maximum of 15 characters
  private void writeName(RandomAccessFile file, String name) throws IOException
    StringBuffer buffer = null;
    if (name != null)
      buffer = new StringBuffer(name);
    else
      buffer = new StringBuffer(15);
    buffer.setLength(15);
    file.writeChars(buffer.toString());
  } // end method writeName
} // end RandomAccessHardwareRecord------------------------------------------------------------------------------------------------
// Exercise 14.11: CreateRandomFile.java
// creates random-access file by writing 100 empty records to disk.
import java.io.IOException;
import java.io.RandomAccessFile;
import org.egan.RandomAccessHardwareRecord;
public class CreateRandomFile
  private static final int NUMBER_RECORDS = 100;
  // enable user to select file to open
  public void createFile()
    RandomAccessFile file = null;
    try  // open file for reading and writing
      file = new RandomAccessFile("hardware.dat","rw");
      RandomAccessHardwareRecord blankRecord = new RandomAccessHardwareRecord();
      // write 100 blank records
      for (int count = 0; count < NUMBER_RECORDS; count++)
        blankRecord.write(file);
      // display message that file was created
      System.out.println("Created file hardware.dat.");
      System.exit(0);  // terminate program
    } // end try
    catch (IOException ioException)
      System.err.println("Error processing file.");
      System.exit(1);
    } // end catch
    finally
      try
        if (file != null)
          file.close();  // close file
      } // end try
      catch (IOException ioException)
        System.err.println("Error closing file.");
        System.exit(1);
      } // end catch
    } // end finally
  } // end method createFile
} // end class CreateRandomFile-------------------------------------------------------------------------------------------------
// Exercise 14.11: CreateRandomFileTest.java
// Testing class CreateRandomFile
public class CreateRandomFileTest
   // main method begins program execution
   public static void main( String args[] )
     CreateRandomFile application = new CreateRandomFile();
     application.createFile();
   } // end main
} // end class CreateRandomFileTest-------------------------------------------------------------------------------------------------
// Exercise 14.11: WriteRandomFile.java
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.util.NoSuchElementException;
import java.util.Scanner;
import org.egan.RandomAccessHardwareRecord;
public class WriteRandomFile
  private RandomAccessFile output;
  private static final int NUMBER_RECORDS = 100;
  // enable user to choose file to open
  public void openFile()
    try // open file
      output = new RandomAccessFile("hardware.dat","rw");
    } // end try
    catch (IOException ioException)
      System.err.println("File does not exist.");
    } // end catch
  } // end method openFile
  // close file and terminate application
  public void closeFile()
    try // close file and exit
      if (output != null)
        output.close();
    } // end try
    catch (IOException ioException)
      System.err.println("Error closing file.");
      System.exit(1);
    } // end catch
  } // end method closeFile
  // add records to file
  public void addRecords()
    // object to be written to file
    RandomAccessHardwareRecord record = new RandomAccessHardwareRecord();
    int recordNumber = 0;
    String toolName;
    int quantity;
    double cost;
    Scanner input = new Scanner(System.in);
    System.out.printf("%s\n%s\n%s\n%s\n\n",
     "To terminate input, type the end-of-file indicator ",
     "when you are prompted to enter input.",
     "On UNIX/Linux/Mac OS X type <ctrl> d then press Enter",
     "On Windows type <ctrl> z then press Enter");
    System.out.printf("%s %s\n%s", "Enter record number (1-100),",
      "tool name, quantity and cost.","? ");
    while (input.hasNext())
      try  // output values to file
        recordNumber = input.nextInt();  // read record number
        toolName = input.next();         // read tool name
        quantity = input.nextInt();      // read quantity
        cost = input.nextDouble();       // read cost
        if (recordNumber > 0 && recordNumber <= NUMBER_RECORDS)
          record.setRecordNumber(recordNumber);
          record.setToolName(toolName);
          record.setQuantity(quantity);
          record.setCost(cost);         
          output.seek((recordNumber - 1) *   // position to proper
           RandomAccessHardwareRecord.SIZE); // location for file
          record.write(output);
        } // end if
        else
          System.out.println("Account must be between 0 and 100.");
      } // end try   
      catch (IOException ioException)
        System.err.println("Error writing to file.");
        return;
      } // end catch
      catch (NoSuchElementException elementException)
        System.err.println("Invalid input. Please try again.");
        input.nextLine();  // discard input so enter can try again
      } // end catch
      System.out.printf("%s %s\n%s","Enter record number (1-100),",
        "tool name, quantity and cost.", "? ");
    } // end while
  } // end method addRecords
} // end class WriteRandomFile-------------------------------------------------------------------------------------------------
// Exercise 14.11: WriteRandomFileTest.java
// Testing class WriteRandomFile
public class WriteRandomFileTest
   // main method begins program execution
   public static void main( String args[] )
     WriteRandomFile application = new WriteRandomFile();
     application.openFile();
     application.addRecords();
     application.closeFile();
   } // end main
} // end class WriteRandomFileTest-------------------------------------------------------------------------------------------------
// Exercise 14.11: ReadRandomFile.java
import java.io.EOFException;
import java.io.IOException;
import java.io.RandomAccessFile;
import org.egan.RandomAccessHardwareRecord;
public class ReadRandomFile
  private RandomAccessFile input;
  // enable user to select file to open
  public void openFile()
    try // open file
      input = new RandomAccessFile("hardware.dat","r");
    } // end try
    catch (IOException ioException)
      System.err.println("File does not exist.");
    } // end catch
  } // end method openFile
  // read and display records
  public void readRecords()
    RandomAccessHardwareRecord record = new RandomAccessHardwareRecord();
    System.out.printf("%-10s%-15s%-15s%10s\n","Record","Tool Name","Quantity","Cost");
    try // read a record and display
      while(true)
        do
          record.read(input);
        }while (record.getRecordNumber() == 0);
        // display record contents
        System.out.printf("%-10d%-12s%-12d%10.2f\n", record.getRecordNumber(),
         record.getToolName(), record.getQuantity(), record.getCost());
      } // end while
    } // end try
    catch (EOFException eofException)
      return; // end of file was reached
    } // end catch
    catch (IOException ioException)
      System.err.println("Error reading file.");
      System.exit(1);
    } // end catch
  }  // end method readRecords
  // close file and terminate application
  public void closeFile()
    try // close file and exit
      if (input != null)
        input.close();
    } // end try
    catch (IOException ioException)
      System.err.println("Error closing file.");
      System.exit(1);
    } // end catch
  } // end methode closeFile
} // end class ReadRandomFile-------------------------------------------------------------------------------------------------
// Exercise 14.11: ReadRandomFileTest.java
// Testing class ReadRandomFile
public class ReadRandomFileTest
   // main method begins program execution
   public static void main( String args[] )
     ReadRandomFile application = new ReadRandomFile();
     application.openFile();
     application.readRecords();
     application.closeFile();
   } // end main
} // end class ReadRandomFileTest-------------------------------------------------------------------------------------------------
Below is the sample data to be inputted in the random file:
Record Tool Name Quantity Cost
Number
3 Sander 18 35.99
19 Hammer 128 10.00
26 Jigsaw 16 14.25
39 Mower 10 79.50
56 Saw 8 89.99
76 Screwdriver 236 4.99
81 Sledgehammer 32 19.75
88 Wrench 65 6.48

Answer 1

I have managed to fix your program.
The solution
The records are sized by the various Writes that occur.
A record is an int + 15 chars + int + double.
WriteInt writes 4 bytes
WriteChar (Called by WriteChars) write 2 bytes
WriteDouble writes 8 bytes.
(In Java 1.5 )
4 bytes + 30 Bytes + 4Bytes + 8 Bytes. = 46 Bytes.
The details are in the API for Random Acces Files at
http://java.sun.com/j2se/1.5.0/docs/api/java/io/RandomAccessFile.html
The code for RandomAccessHardwareRecord line
public statis final int SIZE = 72needs to have the 72 changed to 46
This should make your code work.
I have hacked around with some other bits and will send you my code if you want but that is the key. The asnwers you were getting illustrated a bunch of bytes being read as (say) an int and beacuse of the wrong record length, they were just a bunch of 4 bytes that evaluated to whetever was at that point in the file.
When the record was written the line
output.seek((recordNumber -1 ) * RandomAccessHardwareRecord.SIZE);had SIZE as 72 and so the seek operation stuck the file pointer in the wrong place.
This kind of stuff is good fun and good learning for mentally getting a feel for record filing but in real problems you either serialize your objects or use XML (better) or use jdbc (possibley even better depending on what you are doing).
I would echo sabre comment about the program being poor though because
If the program is meant to teach, it is littered with overly complex statements and if it is meant to be a meaningful program, the objects are too tied to hardware and DAO is the way to go. The problem that the program has indicates that maybe it is maybe fairly old and not written with java 2 in mind.
As for toString() and "Yuk"
Every class inherits toString() from Object. so if you System.out.println(Any object) then you will get something printed. What gets printed is determined by a complex hieracrchy of classes unless you overRide it with your own method.
If you use UnitTesting (which would prevent incorrect code getting as far as this code did in having an error), then toString() methods are really very useful.
Furthermore, IMO Since RandomAccessHardwareRecord knows how to file itself then I hardly think that knowing how to print itself to the console is a capital offence.
In order to expand on the 72 / 46 byte problem.
Message was edited by:
nerak99