Random-Access Files
So far, we have seen how to create and manipulate sequential-access files. Sequential-access files are inappropriate for so-called instant-access applications, in which the desired information must be located immediately. Some popular instant-access applications are airline-reservation systems, banking systems, point-of-sale systems, automated teller machines (ATMs) and other kinds of transaction-processing systems that require rapid access to specific data. The bank at which you have your account may have hundreds of thousands, or even millions, of other customers, but when you use an ATM, the bank determines in seconds whether your account has sufficient funds for the transaction. This kind of instant access is possible with random-access files and with databases (Chapter 25). A program can access individual records of a random-access file directly (and quickly) without searching through other records. Random-access files are sometimes called direct-access files.
Recall from Section 14.5 that Java does not impose structure on a file, so an application that wants to use random-access files must specify the format of those files. Several techniques can be used to create random-access files. Perhaps the simplest is to require that all the records in a file be of the same fixed length. Using fixed-length records makes it easy for a program to calculate (as a function of the record size and the record key) the exact location of any record relative to the beginning of the file. We soon see how this capability facilitates direct access to specific records, even in large files.
Figure 14.22 illustrates Java's view of a random-access file composed of fixed-length records. (Each record in this figure is 100 bytes long.) A random-access file is like a railroad train with many carssome empty, some with contents.
Figure 14.22. Java's view of a random-access file.
A program can insert data in a random-access file without destroying the other data in the file. Similarly, a program can update or delete data stored previously without rewriting the entire file. In the following sections, we explain how to create a random-access file, enter data, read the data both sequentially and randomly, update the data and delete the data.
14.7.1. Creating a Random-Access File
A RandomAccessFile is useful for direct-access applications. With a sequential-access file, each successive input/output request reads or writes the next consecutive set of data in the file. With a random-access file, each successive input/output request could be directed to any part of the fileperhaps a section widely separated from the part referenced in the previous request. Direct-access applications provide rapid access to specific data items in large files, but users often have to wait for answers. In many instances, however, answers must be made available quickly, to prevent people from becoming impatient and taking their business elsewhere.
RandomAccessFile objects have all the capabilities of classes FileInputStream and FileOutputStream, as well as the capabilities described by interfaces DataInput and DataOutput. These interfaces provide methods for reading and writing primitive-type values, byte arrays and strings. When a program associates an object of class RandomAccessFile with a file, the program reads or writes data, beginning at the location in the file specified by the file-position pointer (the byte number of the next byte in the file to be read or written to), and manipulates all the data as primitive types. When writing an int value, four bytes are output to the file. When reading a double value, eight bytes are input from the file. The size of the types is guaranteed, because Java has fixed representations and sizes for all primitive types, regardless of the computing platform.
Random-access file-processing programs rarely write a single field to a file. Normally they write one object at a time, as we show in the upcoming examples. Consider the following problem:
Create a transaction-processing program capable of storing up to 100 fixed-length records for a company that can have up to 100 customers. Each record should consist of an account number (that will be used as the record key), a last name, a first name and a balance. The program should be able to update an account, insert a new account and delete an account.
The next several sections introduce the techniques necessary to create this credit-processing program. Figure 14.23 contains the RandomAccessAccountRecord class that is used by the next four programs for both reading records from and writing records to a file. Class RandomAccessAccountRecord inherits our AccountRecord implementation (Fig. 14.6), which includes private fieldsaccount, lastName, firstName and balanceas well as set and get methods for each field. We could inherit from either AccountRecord or AccountRecordSerializable. We do not use object serialization when processing random-access files in this chapter, so we inherit from class AccountRecord. Note that the class is in package com.deitel.jhtp6.ch14.
Figure 14.23. RandomAccessAccountRecord class used in random-access file programs.
(This item is displayed on pages 708 - 709 in the print version)
|
1 // Fig. 14.23: RandomAccessAccountRecord.java 2 // Subclass of AccountRecord for random-access file programs. 3 package com.deitel.jhtp6.ch14; // packaged for reuse 4 5 import java.io.RandomAccessFile; 6 import java.io.IOException; 7 8 public class RandomAccessAccountRecord extends AccountRecord 9 { 10 public static final int SIZE = 72; 11 12 // no-argument constructor calls other constructor with default values 13 public RandomAccessAccountRecord() 14 { 15 this ( 0, "", "", 0.0 ); 16 } // end no-argument RandomAccessAccountRecord constructor 17 18 // initialize a RandomAccessAccountRecord 19 public RandomAccessAccountRecord( int account, String firstName, 20 String lastName, double balance ) 21 { 22 super( account, firstName, lastName, balance ); 23 } // end four-argument RandomAccessAccountRecord constructor 24 25 // read a record from specified RandomAccessFile 26 public void read( RandomAccessFile file ) throws IOException 27 { 28 setAccount( file.readInt() ); 29 setFirstName( readName( file ) ); 30 setLastName( readName( file ) ); 31 setBalance( file.readDouble() ); 32 } // end method read 33 34 // ensure that name is proper length 35 private String readName( RandomAccessFile file ) throws IOException 36 { 37 char name[] = new char[ 15 ], temp; 38 39 for ( int count = 0; count < name.length; count++ ) 40 { 41 temp = file.readChar(); 42 name[ count ] = temp; 43 } // end for 44 45 return new String( name ).replace( ' ', ' ' ); 46 } // end method readName 47 48 // write a record to specified RandomAccessFile 49 public void write( RandomAccessFile file ) throws IOException 50 { 51 file.writeInt( getAccount() ); 52 writeName( file, getFirstName() ); 53 writeName( file, getLastName() ); 54 file.writeDouble( getBalance() ); 55 } // end method write 56 57 // write a name to file; maximum of 15 characters 58 private void writeName( RandomAccessFile file, String name ) 59 throws IOException 60 { 61 StringBuffer buffer = null; 62 63 if ( name != null ) 64 buffer = new StringBuffer( name ); 65 else 66 buffer = new StringBuffer( 15 ); 67 68 buffer.setLength( 15 ); 69 file.writeChars( buffer.toString() ); 70 } // end method writeName 71 } // end class RandomAccessAccountRecord |
Finally, this example also introduces class StringBuffer, a class that allows us to dynamically manipulate strings. Class String provides many capabilities for processing strings. However, String objects are immutabletheir character contents cannot be changed after they are created. Class StringBuffer provides features for creating and manipulating dynamic string informationthat is, modifiable strings. Every StringBuffer is capable of storing a number of characters specified by its capacity. If the capacity of a StringBuffer is exceeded, the capacity is expanded to accommodate the additional characters. We use class StringBuffer to specify the size of a person's first or last name. We discuss class StringBuffer in more detail in Section 14.8, as well as in Chapter 29, Strings, Characters and Regular Expressions.
Line 10 declares the constant SIZE to represent the size, in bytes, of a record. A RandomAccessAccountRecord contains an int (4 bytes), two strings that we restrict to 15 characters each (30 bytes for the first name, 30 bytes for the last name) for this example and a double (8 bytes), for a total of 72 bytes.
Method read (lines 2632) reads one record from the RandomAccessFile specified as its argument. RandomAccessFile methods readInt (line 28) and readDouble (line 31) read the account and balance, respectively. Lines 2930 call utility method readName (lines 3546) twice to obtain the first and last names. Method readName reads 15 characters from the RandomAccessFile and returns a String. If a name is shorter than 15 characters, the extra characters have the default value ' 'the default for a char. Swing GUI components, such as JTextFields, cannot display null-byte charactersinstead, they display them as rectangles. Line 45 solves this problem by using String method replace to replace null bytes with spaces. Although our program does not use a GUI, we added this capability for those who wish to reuse this class in a GUI program.
Method write (lines 4955) outputs one record to the RandomAccessFile specified as its argument. This method uses RandomAccessFile method writeInt to output the integer account, method writeChars (called from utility method writeName in line 69) to output the firstName and lastName character arrays, and method writeDouble to output the double balance. [Note: To ensure that all the records in the RandomAccessFile are the same size, we write exactly 15 characters for the first name and exactly 15 for the last name.] Method writeName (lines 5870) performs the write operations for the first and last names. Lines 6366 create a StringBuffer that is initialized with either the name specified as an argument or with 15 to specify the size of the StringBuffer if name is null. Line 68 sets the number of characters in the StringBuffer. If a name is longer than 15 characters, it will be truncated to 15 characters. If a name is smaller than 15 characters it will be set to have 15 characters, with null characters (' ') to fill the extra space.
Figure 14.24Fig. 14.25 illustrates the process of opening a random-access file and writing data to the disk. This program writes 100 blank RandomAccessAccountRecords. Each RandomAccessAccountRecord object contains 0 for the account number, null for the last name, null for the first name and 0.0 for the balance. The file is initialized to create the proper amount of "empty" space in which the account data will be stored and to enable us to determine in subsequent programs whether each record is empty or contains data.
Figure 14.24. Random-access file created sequentially.
(This item is displayed on page 711 in the print version)
|
1 // Fig. 14.24: CreateRandomFile.java 2 // Creates random-access file by writing 100 empty records to disk. 3 import java.io.IOException; 4 import java.io.RandomAccessFile; 5 6 import com.deitel.jhtp6.ch14.RandomAccessAccountRecord; 7 8 public class CreateRandomFile 9 { 10 private static final int NUMBER_RECORDS = 100; 11 12 // enable user to select file to open 13 public void createFile() 14 { 15 RandomAccessFile file = null; 16 17 try // open file for reading and writing 18 { 19 file = new RandomAccessFile( "clients.dat", "rw" ); 20 21 RandomAccessAccountRecord blankRecord = 22 new RandomAccessAccountRecord(); 23 24 // write 100 blank records 25 for ( int count = 0 ; count < NUMBER_RECORDS; count++ ) 26 blankRecord.write( file ); 27 28 // display message that file was created 29 System.out.println( "Created file clients.dat." ); 30 31 System.exit( 0 ); // terminate program 32 } // end try 33 catch ( IOException ioException ) 34 { 35 System.err.println( "Error processing file." ); 36 System.exit( 1 ); 37 } // end catch 38 finally 39 { 40 try 41 { 42 if ( file != null ) 43 file.close(); // close file 44 } // end try 45 catch ( IOException ioException ) 46 { 47 System.err.println( "Error closing file." ); 48 System.exit( 1 ); 49 } // end catch 50 } // end finally 51 } // end method createFile 52 } // end class CreateRandomFile |
Figure 14.25. Testing class CreateRandomFile.
(This item is displayed on page 712 in the print version)
|
1 // Fig. 14.25: CreateRandomFileTest.java 2 // Testing class CreateRandomFile. 3 4 public class CreateRandomFileTest 5 { 6 public static void main( String args[] ) 7 { 8 CreateRandomFile application = new CreateRandomFile(); 9 application.createFile(); 10 } // end main 11 } // end class CreateRandomFileTest
|
Line 19 of Fig. 14.24 attempts to open a RandomAccessFile for use in this program. The RandomAccessFile constructor accepts two argumentsthe file name and the file-open mode. The file-open mode for a RandomAccessFile is either "r" (to open the file for reading) or "rw" (to open the file for reading and writing). Once again, we have used a new file extension (.dat). We use this file extension for binary files that do not use object serialization.
If an IOException occurs while opening the file, the program displays a message and terminates. If the file opens properly, lines 2526 invoke RandomAccessAccountRecord method write 100 times. This method causes the fields of object blankRecord to be written to the file associated with RandomAccessFile object file. Then line 43 closes the file. The code for closing the file is placed in it's own try statementif an attempt to close the file generates an IOException, this exception is caught in lines 4549. Figure 14.25 begins the execution of the program with method main (lines 610). Line 8 creates a CreateRandomFile object and line 9 calls its createFile method to create the file of 100 blank records.
14.7.2. Writing Data Randomly to a Random-Access File
The application in Fig. 14.26Fig. 14.27 writes data to a file that is opened with the "rw" mode (for reading and writing). It uses RandomAccessFile method seek to position to the exact location in the file at which a record of information is stored. Method seek sets the file-position pointer to a specific location in the file relative to the beginning of the file, and RandomAccessAccountRecord method write outputs the data at the current position in the file. The program assumes that the user does not enter duplicate account numbers.
Figure 14.26. Writing data to a random-access file.
(This item is displayed on pages 712 - 714 in the print version)
|
1 // Fig. 14.26: WriteRandomFile.java 2 // This program retrieves information from the user at the 3 // keyboard and writes the information to a random-access file. 4 import java.io.File; 5 import java.io.IOException; 6 import java.io.RandomAccessFile; 7 import java.util.NoSuchElementException; 8 import java.util.Scanner; 9 10 import com.deitel.jhtp6.ch14.RandomAccessAccountRecord; 11 12 public class WriteRandomFile 13 { 14 private RandomAccessFile output; 15 16 private static final int NUMBER_RECORDS = 100; 17 18 // enable user to choose file to open 19 public void openFile() 20 { 21 try // open file 22 { 23 output = new RandomAccessFile( "clients.dat", "rw" ); 24 } // end try 25 catch ( IOException ioException ) 26 { 27 System.err.println( "File does not exist." ); 28 } // end catch 29 } // end method openFile 30 31 // close file and terminate application 32 public void closeFile() 33 { 34 try // close file and exit 35 { 36 if ( output != null ) 37 output.close(); 38 } // end try 39 catch ( IOException ioException ) 40 { 41 System.err.println( "Error closing file." ); 42 System.exit( 1 ); 43 } // end catch 44 } // end method closeFile 45 46 // add records to file 47 public void addRecords() 48 { 49 // object to be written to file 50 RandomAccessAccountRecord record = new RandomAccessAccountRecord(); 51 52 int accountNumber = 0 ; // account number for AccountRecord object 53 String firstName; // first name for AccountRecord object 54 String lastName; // last name for AccountRecord object 55 double balance; // balance for AccountRecord object 56 57 Scanner input = new Scanner( System.in ); 58 59 System.out.printf( "%s %s %s %s ", 60 "To terminate input, type the end-of-file indicator ", 61 "when you are prompted to enter input.", 62 "On UNIX/Linux/Mac OS X type d then press Enter", 63 "On Windows type z then press Enter" ); 64 65 System.out.printf( "%s %s %s", "Enter account number (1-100),", 66 "first name, last name and balance.", "? " ); 67 68 while ( input.hasNext() ) // loop until end-of-file indicator 69 { 70 try // output values to file 71 { 72 accountNumber = input.nextInt(); // read account number 73 firstName = input.next(); // read first name 74 lastName = input.next(); // read last name 75 balance = input.nextDouble(); // read balance 76 77 if ( accountNumber > 0 && accountNumber <= NUMBER_RECORDS ) 78 { 79 record.setAccount( accountNumber ); 80 record.setFirstName( firstName ); 81 record.setLastName( lastName ); 82 record.setBalance( balance ); 83 84 output.seek( ( accountNumber - 1 ) * // position to proper 85 RandomAccessAccountRecord.SIZE ); // location for file 86 record.write( output ); 87 } // end if 88 else 89 System.out.println( "Account must be between 0 and 100." ); 90 } // end try 91 catch ( IOException ioException ) 92 { 93 System.err.println( "Error writing to file." ); 94 return; 95 } // end catch 96 catch ( NoSuchElementException elementException ) 97 { 98 System.err.println( "Invalid input. Please try again." ); 99 input.nextLine(); // discard input so user can try again 100 } // end catch 101 102 System.out.printf( "%s %s %s", "Enter account number (1-100),", 103 "first name, last name and balance.", "? " ); 104 } // end while 105 } // end method addRecords 106 } // end class WriteRandomFile |
Figure 14.27. Testing class WriteRandomFile.
(This item is displayed on page 715 in the print version)
|
1 // Fig. 14.27: WriteRandomFileTest.java 2 // This program tests class WriteRandomFile. 3 4 public class WriteRandomFileTest 5 { 6 public static void main( String args[] ) 7 { 8 WriteRandomFile application = new WriteRandomFile(); 9 application.openFile(); 10 application.addRecords(); 11 application.closeFile(); 12 } // end main 13 } // end class WriteRandomFileTest
|
The user enters values for the account number, first name, last name and balance. After each record is entered, the program stores the data in RandomAccessAccountRecord object record (lines 7982 of Figure 14.26) and calls record's write method to output the data (line 86).
Lines 8485 call RandomAccessFile method seek to position the file-position pointer for object output to the byte location calculated by ( accountNumber - 1 ) * RandomAccessAccountRecord. SIZE. Account numbers in this program are in the range 1100. We subtract one from the account number when calculating the byte location of the record. Thus, for record one, the file-position pointer is set to byte zero of the file. For record 100, the file-position pointer is set to skip the first 99 records in the file.
14.7.3. Reading Data Sequentially from a Random-Access File
In the preceding sections, we created a random-access file and wrote data to it. In this section, we develop a program (Fig. 14.28Fig. 14.29) that opens a RandomAccessFile for reading with the "r" file-open mode (line 19 of Fig. 14.28), reads through the file sequentially and displays only those records containing data. The program produces an additional benefit. See whether you can determine what it iswe reveal it at the end of this section.
Figure 14.28. Reading data sequentially from a random-access file.
(This item is displayed on pages 716 - 717 in the print version)
|
1 // Fig. 14.28: ReadRandomFile.java 2 // This program reads a random-access file sequentially and 3 // displays the contents one record at a time in text fields. 4 import java.io.EOFException; 5 import java.io.IOException; 6 import java.io.RandomAccessFile; 7 8 import com.deitel.jhtp6.ch14.RandomAccessAccountRecord; 9 10 public class ReadRandomFile 11 { 12 private RandomAccessFile input; 13 14 // enable user to select file to open 15 public void openFile() 16 { 17 try // open file 18 { 19 input = new RandomAccessFile( "clients.dat", "r" ); 20 } // end try 21 catch ( IOException ioException ) 22 { 23 System.err.println( "File does not exist." ); 24 } // end catch 25 } // end method openFile 26 27 // read and display records 28 public void readRecords() 29 { 30 RandomAccessAccountRecord record = new RandomAccessAccountRecord(); 31 32 System.out.printf( "%-10s%-15s%-15s%10s ", "Account", 33 "First Name", "Last Name", "Balance" ); 34 35 try // read a record and display 36 { 37 while ( true ) 38 { 39 do 40 { 41 record.read( input ); 42 } while ( record.getAccount() == 0 ); 43 44 // display record contents 45 System.out.printf( "%-10d%-12s%-12s%10.2f ", 46 record.getAccount(), record.getFirstName(), 47 record.getLastName(), record.getBalance() ); 48 } // end while 49 } // end try 50 catch ( EOFException eofException ) // close file 51 { 52 return; // end of file was reached 53 } // end catch 54 catch ( IOException ioException ) 55 { 56 System.err.println( "Error reading file." ); 57 System.exit( 1 ); 58 } // end catch 59 } // end method readRecords 60 61 // close file and terminate application 62 public void closeFile() 63 { 64 try // close file and exit 65 { 66 if ( input != null ) 67 input.close(); 68 } // end try 69 catch ( IOException ioException ) 70 { 71 System.err.println( "Error closing file." ); 72 System.exit( 1 ); 73 } // end catch 74 } // end method closeFile 75 } // end class ReadRandomFile |
Figure 14.29. Testing class ReadRandomFile.
(This item is displayed on page 717 in the print version)
|
1 // Fig. 14.29: ReadRandomFileTest.java 2 // Testing class ReadRandomFile. 3 4 public class ReadRandomFileTest 5 { 6 public static void main( String args[] ) 7 { 8 ReadRandomFile application = new ReadRandomFile(); 9 application.openFile(); 10 application.readRecords(); 11 application.closeFile(); 12 } // end main 13 } // end class ReadRandomFileTest
|
Good Programming Practice 14.1
|
Open a file with the "r" file-open mode for input if the contents should not be modified. This practice prevents unintentional modification of the file's contents. This is another example of the principle of least privilege. |
The program reads records by invoking method readRecords (lines 2859). This method invokes class RandomAccessAccountRecord's read method (line 41) to read one record's data into RandomAccessAccountRecord object record. Method readRecords reads from the file using two loops. The outer loop, a while statement, loops until an attempt is made to read past the end of the file. The inner loop, a do...while statement, is used to read records until one is encountered with a nonzero account number (zero is the account number for empty records). At this point, the record is displayed. When all the records have been read, the file is closed and the program terminates. Figure 14.29 contains method main and begins the execution of the program. Lines 911 open the file, call method readRecords and close the file.
What about that additional benefit we promised? If you examine the output, you will notice that the records are displayed in sorted order (by account number)! This ordering is a simple consequence of the way we stored these records in the file, using direct-access techniques. Sorting with direct-access techniques is blazingly fast. The speed is achieved by making the file large enough to hold every possible record that might be created, which enables the program to insert a record between other records without having to reorganize the file. This configuration, of course, means that the file could be sparsely occupied most of the time, a waste of storage. So this situation is another example of the space/time trade-off. By using large amounts of space, we are able to develop a much faster sorting algorithm.
14.7.4. Case Study: A Transaction-Processing Program
We now present a substantial transaction-processing program (Fig. 14.33Fig. 14.36), using a random-access file to achieve instant-access processing. The program maintains a bank's account informationit displays existing accounts, updates accounts, adds new accounts and deletes accounts. We assume that the program in Fig. 14.24Fig. 14.25 has been executed to create a file, and that the program in Fig. 14.26Fig. 14.27 has been executed to insert initial data. The techniques used in this example were presented in the earlier RandomAccessFile examples.
The program has five options. Option 1 displays a list of all the accounts in the file, using the same techniques as in the preceding section. Choosing option 1 displays the information in Fig. 14.30.
Figure 14.30. Transaction processor displaying records.
|
Option 2 is used to update an account. The application will only update an existing record, so the function first checks to see whether the record specified by the user is empty. The record is read from the file, then the account number is compared to 0. If it is 0, the record contains no information, and a message is printed stating that the record is empty. Then, the menu choices are displayed. If the record contains information, the record's current information is displayed first. The user is then prompted for a change in the balance (either a charge or a payment), and the updated record is displayed. A typical output for option 2 is shown in Fig. 14.31.
Figure 14.31. Transaction processor updating a record.
(This item is displayed on page 719 in the print version)
|
Option 3 is used to add a new account to the file. The user is prompted to enter information for a new record. If the user enters an account number for an existing account, an error message is displayed indicating that the record already contains information, and the menu choices are printed again. If the account number entered does not correspond to an existing record (and all the data entered is valid), the new record is created and stored in the file. This code for this option uses the same process to add a new account as does the program in Fig. 14.26Fig. 14.27. A typical output for option 3 is shown in Fig. 14.32.
Figure 14.32. Transaction processor inserting a record.
|
Option 4 is used to delete a record from the file. Deletion is accomplished by asking the user for the account number and reinitializing the record (i.e., writing a blank record in its place). If the account contains no information, deleteRecord displays an error message stating that the account does not exist. Option 5 terminates program execution. The program is shown in Fig. 14.33Fig. 14.36. Figure 14.33 defines the enum type for the user's options. The options are listed in lines 711.
Figure 14.33. Transaction processor's menu options.
|
1 // Fig. 14.33: MenuOption.java 2 // Defines an enum type for the credit inquiry program's options. 3 4 public enum MenuOption 5 { 6 // declare contents of enum type 7 PRINT( 1 ), 8 UPDATE( 2 ), 9 NEW( 3 ), 10 DELETE( 4 ), 11 END( 5 ); 12 13 private final int value; // current menu option 14 15 MenuOption( int valueOption ) 16 { 17 value = valueOption; 18 } // end MenuOptions enum constructor 19 20 public int getValue() 21 { 22 return value; 23 } // end method getValue 24 } // end enum MenuOption |
Class FileEditor (Fig. 14.34) declares methods for manipulating records in a random-access file. This class uses all the techniques shown in the earlier examples. Method getrecord (lines 3145) reads the record with the given account number and stores its information in a RandomAccessAccountRecord object. Method updateRecord (lines 4864) modifies the record with the given account number, as long as the account number corresponds to a non-empty record. Method newRecord (lines 6783) adds a new record to the file using the provided account number, first name, last name and balance. Method deleteRecord (lines 86100) deletes the record with the given account number from the file, provided that the specified account exists. Method readRecords (lines 103136) displays all the currently existing records in the file.
Figure 14.34. FileEditor class that encapsulates the file-processing capabilities required in Fig. 14.35.
(This item is displayed on pages 720 - 722 in the print version)
|
1 // Fig. 14.34: FileEditor.java 2 // This class declares methods that manipulate bank account 3 // records in a random access file. 4 import java.io.EOFException; 5 import java.io.File; 6 import java.io.IOException; 7 import java.io.RandomAccessFile; 8 import java.util.Scanner; 9 10 import com.deitel.jhtp6.ch14.RandomAccessAccountRecord; 11 12 public class FileEditor 13 { 14 RandomAccessFile file; // reference to the file 15 Scanner input = new Scanner( System.in ); 16 17 // open the file 18 public FileEditor( String fileName ) throws IOException 19 { 20 file = new RandomAccessFile( fileName, "rw" ); 21 } // end FileEditor constructor 22 23 // close the file 24 public void closeFile() throws IOException 25 { 26 if ( file != null ) 27 file.close(); 28 } // end method closeFile 29 30 // get a record from the file 31 public RandomAccessAccountRecord getRecord( int accountNumber ) 32 throws IllegalArgumentException, NumberFormatException, IOException 33 { 34 RandomAccessAccountRecord record = new RandomAccessAccountRecord(); 35 36 if ( accountNumber < 1 || accountNumber > 100 ) 37 throw new IllegalArgumentException( "Out of range" ); 38 39 // seek appropriate record in file 40 file.seek( ( accountNumber - 1 ) * RandomAccessAccountRecord.SIZE ); 41 42 record.read( file ); 43 44 return record; 45 } // end method getRecord 46 47 // update record in file 48 public void updateRecord( int accountNumber, double transaction ) 49 throws IllegalArgumentException, IOException 50 { 51 RandomAccessAccountRecord record = getRecord( accountNumber ); 52 53 if ( record.getAccount() == 0 ) 54 throw new IllegalArgumentException( "Account does not exist" ); 55 56 // seek appropriate record in file 57 file.seek( ( accountNumber - 1 ) * RandomAccessAccountRecord.SIZE ); 58 59 record = new RandomAccessAccountRecord( 60 record.getAccount(), record.getFirstName(), 61 record.getLastName(), record.getBalance() + transaction ); 62 63 record.write( file ); // write updated record to file 64 } // end method updateRecord 65 66 // add record to file 67 public void newRecord( int accountNumber, String firstName, 68 String lastName, double balance ) 69 throws IllegalArgumentException, IOException 70 { 71 RandomAccessAccountRecord record = getRecord( accountNumber ); 72 73 if ( record.getAccount() != 0 ) 74 throw new IllegalArgumentException( "Account already exists" ); 75 76 // seek appropriate record in file 77 file.seek( ( accountNumber - 1 ) * RandomAccessAccountRecord.SIZE ); 78 79 record = new RandomAccessAccountRecord( accountNumber, 80 firstName, lastName, balance ); 81 82 record.write( file ); // write record to file 83 } // end method newRecord 84 85 // delete record from file 86 public void deleteRecord( int accountNumber ) 87 throws IllegalArgumentException, IOException 88 { 89 RandomAccessAccountRecord record = getRecord( accountNumber ); 90 91 if ( record.getAccount() == 0 ) 92 throw new IllegalArgumentException( "Account does not exist" ); 93 94 // seek appropriate record in file 95 file.seek( ( accountNumber - 1 ) * RandomAccessAccountRecord.SIZE ); 96 97 // create a blank record to write to the file 98 record = new RandomAccessAccountRecord(); 99 record.write( file ); 100 } // end method deleteRecord 101 102 // read and display records 103 public void readRecords() 104 { 105 RandomAccessAccountRecord record = new RandomAccessAccountRecord(); 106 107 System.out.printf( "%-10s%-15s%-15s%10s ", "Account", 108 "First Name", "Last Name", "Balance" ); 109 110 try // read a record and display 111 { 112 file.seek( 0 ); 113 114 while ( true ) 115 { 116 do 117 { 118 record.read( file ); 119 } while ( record.getAccount() == 0 ); 120 121 // display record contents 122 System.out.printf( "%-10d%-15s%-15s%10.2f ", 123 record.getAccount(), record.getFirstName(), 124 record.getLastName(), record.getBalance() ); 125 } // end while 126 } // end try 127 catch ( EOFException eofException ) // close file 128 { 129 return; // end of file was reached 130 } // end catch 131 catch ( IOException ioException ) 132 { 133 System.err.println( "Error reading file." ); 134 System.exit( 1 ); 135 } // end catch 136 } // end method readRecords 137 } // end class FileEditor |
Class transactionProcessor (Fig. 14.35) displays the menu for the application and manages the interactions with the FileEditor object that is created in the openFile method (lines 2034).
Figure 14.35. Transaction-processing program.
(This item is displayed on pages 723 - 726 in the print version)
|
1 // Fig. 14.35: TransactionProcessor.java 2 // A transaction processing program using random-access files. 3 import java.io.IOException; 4 import java.util.NoSuchElementException; 5 import java.util.Scanner; 6 7 import com.deitel.jhtp6.ch14.RandomAccessAccountRecord; 8 9 public class TransactionProcessor 10 { 11 private FileEditor dataFile; 12 private RandomAccessAccountRecord record; 13 private MenuOption choices[] = { MenuOption.PRINT, 14 MenuOption.UPDATE, MenuOption.NEW, 15 MenuOption.DELETE, MenuOption.END }; 16 17 private Scanner input = new Scanner( System.in ); 18 19 // get the file name and open the file 20 private boolean openFile() 21 { 22 try // attempt to open file 23 { 24 // call the helper method to open the file 25 dataFile = new FileEditor( "clients.dat" ); 26 } // end try 27 catch ( IOException ioException ) 28 { 29 System.err.println( "Error opening file." ); 30 return false; 31 } // end catch 32 33 return true; 34 } // end method openFile 35 36 // close file and terminate application 37 private void closeFile() 38 { 39 try // close file 40 { 41 dataFile.closeFile(); 42 } // end try 43 catch ( IOException ioException ) 44 { 45 System.err.println( "Error closing file." ); 46 System.exit( 1 ); 47 } // end catch 48 } // end method closeFile 49 50 // create, update or delete the record 51 private void performAction( MenuOption action ) 52 { 53 int accountNumber = 0; // account number of record 54 String firstName; // first name for account 55 String lastName; // last name for account 56 double balance; // account balance 57 double transaction; // amount to change in balance 58 59 try // attempt to manipulate files based on option selected 60 { 61 switch ( action ) // switch based on option selected 62 { 63 case PRINT: 64 System.out.println(); 65 dataFile.readRecords(); 66 break; 67 case NEW: 68 System.out.printf( " %s%s %s %s", 69 "Enter account number,", 70 " first name, last name and balance.", 71 "(Account number must be 1 - 100)", "? " ); 72 73 accountNumber = input.nextInt(); // read account number 74 firstName = input.next(); // read first name 75 lastName = input.next(); // read last name 76 balance = input.nextDouble(); // read balance 77 78 dataFile.newRecord( accountNumber, firstName, 79 lastName, balance ); // create new record 80 break; 81 case UPDATE: 82 System.out.print( 83 " Enter account to update ( 1 - 100 ): " ); 84 accountNumber = input.nextInt(); 85 record = dataFile.getRecord( accountNumber ); 86 87 if ( record.getAccount() == 0 ) 88 System.out.println( "Account does not exist." ); 89 else 90 { 91 // display record contents 92 System.out.printf( "%-10d%-12s%-12s%10.2f ", 93 record.getAccount(), record.getFirstName(), 94 record.getLastName(), record.getBalance() ); 95 96 System.out.print( 97 "Enter charge ( + ) or payment ( - ): " ); 98 transaction = input.nextDouble(); 99 dataFile.updateRecord( accountNumber, // update record 100 transaction ); 101 102 // retrieve updated record 103 record = dataFile.getRecord( accountNumber ); 104 105 // display updated record 106 System.out.printf( "%-10d%-12s%-12s%10.2f ", 107 record.getAccount(), record.getFirstName(), 108 record.getLastName(), record.getBalance() ); 109 } // end else 110 break; 111 case DELETE: 112 System.out.print( 113 " Enter an account to delete (1 - 100): " ); 114 accountNumber = input.nextInt(); 115 116 dataFile.deleteRecord( accountNumber ); // delete record 117 break; 118 default: 119 System.out.println( "Invalid action." ); 120 break; 121 } // end switch 122 } // end try 123 catch ( NumberFormatException format ) 124 { 125 System.err.println( "Bad input." ); 126 } // end catch 127 catch ( IllegalArgumentException badAccount ) 128 { 129 System.err.println( badAccount.getMessage() ); 130 } // end catch 131 catch ( IOException ioException ) 132 { 133 System.err.println( "Error writing to the file." ); 134 } // end catch 135 catch ( NoSuchElementException elementException ) 136 { 137 System.err.println( "Invalid input. Please try again." ); 138 input.nextLine(); // discard input so user can try again 139 } // end catch 140 } // end method performAction 141 142 // enable user to input menu choice 143 private MenuOption enterChoice() 144 { 145 int menuChoice = 1; 146 147 // display available options 148 System.out.printf( " %s %s %s %s %s %s", 149 "Enter your choice", "1 - List accounts", 150 "2 - Update an account", "3 - Add a new account", 151 "4 - Delete an account", "5 - End program ? " ); 152 153 try 154 { 155 menuChoice = input.nextInt(); 156 } 157 catch ( NoSuchElementException elementException ) 158 { 159 System.err.println( "Invalid input." ); 160 System.exit( 1 ); 161 } // end catch 162 163 return choices[ menuChoice - 1 ]; // return choice from user 164 } // end enterChoice 165 166 public void processRequests() 167 { 168 openFile(); 169 170 // get user's request 171 MenuOption choice = enterChoice(); 172 173 while ( choice != MenuOption.END ) 174 { 175 performAction (choice ); 176 choice = enterChoice(); 177 } // end while 178 179 closeFile(); 180 } // end method processRequests 181 } // end class TransactionProcessor |
Figure 14.36. Testing class transactionProcessor.
(This item is displayed on page 726 in the print version)
|
1 // Fig. 14.36: TransactionProcessorTest.java 2 // Testing the transaction processor. 3 4 public class TransactionProcessorTest 5 { 6 public static void main( String args[] ) 7 { 8 TransactionProcessor application = new TransactionProcessor(); 9 application.processRequests(); 10 } // end main 11 } // end class TransactionProcessorTest |
Method processRequests (lines 166180) processes the choices entered by the user. If the user does not enter 5 (which ends the program), method performAction (lines 51140) is called. This method inputs information from the user and sends it to the appropriate method of class FileEditor (Fig. 14.34), which encapsulates the file-processing operations in this example. The method to call is determined by performAction's MenuOption argument. Each option is handled in the switch statement of lines 61121. Method performAction also handles any exceptions that might be thrown from FileEditor's methods.