Sequential-Access Text Files
Sequential-Access Text Files
In this section, we create and manipulate sequential-access files. As mentioned earlier, these are files in which records are stored in order by the record-key field. We first demonstrate sequential-access files using text files, allowing the reader to quickly create and edit human-readable files. In the subsections of this chapter we discuss creating, writing data to, reading data from and updating sequential-access text files. We also include a credit-inquiry program that retrieves specific data from a file.
Creating a Sequential-Access Text File
Java imposes no structure on a filenotions such as a record do not exist as part of the Java language. Therefore, the programmer must structure files to meet the requirements of the intended application. In the following example, we see how to impose a record structure on a file.
The program in Example 14.6Example 14.7 and Example 14.9 creates a simple sequential-access file that might be used in an accounts receivable system to help keep track of the amounts owed to a company by its credit clients. For each client, the program obtains from the user an account number, the client's name and the client's balance (i.e., the amount the client owes the company for goods and services received). The data obtained for each client constitutes a "record" for that client. The account number is used as the record key in this applicationthe file will be created and maintained in account number order. The program assumes that the user enters the records in account number order. In a comprehensive accounts receivable system (based on sequential-access files), a sorting capability would be provided so that the user could enter the records in any order. The records would then be sorted and written to the file.
Example 14.6. AccountRecord maintains information for one account.
1 // Example 14.6: AccountRecord.java
2 // A class that represents one record of information.
3 package com.deitel.jhtp6.ch14; // packaged for reuse
4
5 public class AccountRecord
6 {
7 private int account;
8 private String firstName;
9 private String lastName;
10 private double balance;
11
12 // no-argument constructor calls other constructor with default values
13 public AccountRecord()
14 {
15 this ( 0, "", "", ); // call four-argument constructor
16 } // end no-argument AccountRecord constructor
17
18 // initialize a record
19 public AccountRecord( int acct, String first, String last, double bal )
20 {
21 setAccount( acct );
22 setFirstName( first );
23 setLastName( last );
24 setBalance( bal );
25 } // end four-argument AccountRecord constructor
26
27 // set account number
28 public void setAccount( int acct )
29 {
30 account = acct;
31 } // end method setAccount
32
33 // get account number
34 public int getAccount()
35 {
36 return account;
37 } // end method getAccount
38
39 // set first name
40 public void setFirstName( String first )
41 {
42 firstName = first;
43 } // end method setFirstName
44
45 // get first name
46 public String getFirstName()
47 {
48 return firstName;
49 } // end method getFirstName
50
51 // set last name
52 public void setLastName( String last )
53 {
54 lastName = last;
55 } // end method setLastName
56
57 // get last name
58 public String getLastName()
59 {
60 return lastName;
61 } // end method getLastName
62
63 // set balance
64 public void setBalance( double bal )
65 {
66 balance = bal;
67 } // end method setBalance
68
69 // get balance
70 public double getBalance()
71 {
72 return balance;
73 } // end method getBalance
74 } // end class AccountRecord
|
Example 14.7. Creating a sequential text file.
1 // Example 14.7: CreateTextFile.java
2 // Writing data to a text file with class Formatter.
3 import java.io.FileNotFoundException;
4 import java.lang.SecurityException;
5 import java.util.Formatter;
6 import java.util.FormatterClosedException;
7 import java.util.NoSuchElementException;
8 import java.util.Scanner;
9
10 import com.deitel.jhtp6.ch14.AccountRecord;
11
12 public class CreateTextFile
13 {
14 private Formatter output; // object used to output text to file
15
16 // enable user to open file
17 public void openFile()
18 {
19 try
20 {
21 output = new Formatter( "clients.txt" );
22 } // end try
23 catch ( SecurityException securityException )
24 {
25 System.err.println(
26 "You do not have write access to this file." );
27 System.exit( 1 );
28 } // end catch
29 catch ( FileNotFoundException filesNotFoundException )
30 {
31 System.err.println( "Error creating file." );
32 System.exit( 1 );
33 } // end catch
34 } // end method openFile
35
36 // add records to file
37 public void addRecords()
38 {
39 // object to be written to file
40 AccountRecord record = new AccountRecord();
41
42 Scanner input = new Scanner( System.in );
43
44 System.out.printf( "%s\n%s\n%s\n%s\n\n",
45 "To terminate input, type the end-of-file indicator ",
46 "when you are prompted to enter input.",
47 "On UNIX/Linux/Mac OS X type <ctrl> d then press Enter",
48 "On Windows type <ctrl> z then press Enter" );
49
50 System.out.printf( "%s\n%s",
51 "Enter account number (> 0), first name, last name and balance.",
52 "? " );
53
54 while ( input.hasNext() ) // loop until end-of-file indicator
55 {
56 try // output values to file
57 {
58 // retrieve data to be output
59 record.setAccount( input.nextInt() ); // read account number
60 record.setFirstName( input.next() ); // read first name
61 record.setLastName( input.next() ); // read last name
62 record.setBalance( input.nextDouble() ); // read balance
63
64 if ( record.getAccount() > 0 )
65 {
66 // write new record
67 output.format( "%d %s %s %.2f\n", record.getAccount(),
68 record.getFirstName(), record.getLastName(),
69 record.getBalance() );
70 } // end if
71 else
72 {
73 System.out.println(
74 "Account number must be greater than 0." );
75 } // end else
76 } // end try
77 catch ( FormatterClosedException formatterClosedException )
78 {
79 System.err.println( "Error writing to file." );
80 return;
81 } // end catch
82 catch ( NoSuchElementException elementException )
83 {
84 System.err.println( "Invalid input. Please try again." );
85 input.nextLine(); // discard input so user can try again
86 } // end catch
87
88 System.out.printf( "%s %s\n%s", "Enter account number (>0),",
89 "first name, last name and balance.", "? " );
90 } // end while
91 } // end method addRecords
92
93 // close file
94 public void closeFile()
95 {
96 if ( output != null )
97 output.close();
98 } // end method closeFile
99 } // end class CreateTextFile
|
Class AccountRecord (Example 14.6) encapsulates the client record information (i.e., account, first name, etc.) used by the examples in this chapter. The class AccountRecord is declared in package com.deitel.jhtp6.ch14 (line 3), so that it can be imported into several examples. Class AccountRecord contains private data members account, firstName, lastName and balance (lines 710). This class also provides public set and get methods for accessing the private fields.
Compile class AccountRecord as follows:
javac -d c:\examples\ch14 com\deitel\jhtp6\ch14\AccountRecord.java
This places AccountRecord.class in its package directory structure and places the package in c:\examples\ch14. When you compile class AccountRecord (or any other classes that will be reused in this chapter), you should place them in a common directory (e.g., c:\examples\ch14). When you compile or execute classes that use AccountRecord (e.g., CreateTextFile in Example 14.7), you must specify the command-line argument - classpath to both javac and java, as in
javac -classpath .;c:\examples\ch14 CreateTextFile.java java -classpath .;c:\examples\ch14 CreateTextFile
Note that the current directory (specified with .) is included in the classpath. This ensures that the compiler can locate other classes in the same directory as the class being compiled. The path separator used in the preceding commands should be the one that is appropriate for your platformfor example, a semicolon (;) on Windows and a colon (:) on UNIX/ Linux/Mac OS X.
Now let us examine class CreateTextFile (Example 14.7). Line 14 declares Formatter variable output. As discussed in , a Formatter object outputs formatted strings, using the same formatting capabilities as method System.out.printf. A Formatter object can output to various locations, such as the screen or a file, as is done here. The Formatter object is instantiated in line 21 in method openFile (lines 1734). The constructor used in line 21 takes one argumenta String containing the name of the file, including its path. If a path is not specified, as is the case here, the JVM assumes that the files is in the directory from which the program was executed. For text files, we use the .txt file extension. If the file does not exist, it will be created. If an existing file is opened, the contents of the file are truncatedall the data in the file is discarded. At this point the file is open for writing, and the resulting Formatter object can be used to write data to the file. Lines 2328 handle the SecurityException, which occurs if the user does not have permission to write data to the file. Lines 2933 handle the FileNotFoundException, which occurs if the file does not exist and a new file cannot be created. This exception may also occur if there is an error opening the file. Note that in both exception handlers, we call static method System.exit, and pass the value 1. This method terminates the application. An argument of 0 to method exit indicates successful program termination. A nonzero value, such as 1 in this example, normally indicates that an error has occurred. This value is passed to the command window that executed the program. The argument is useful if the program is executed from a batch file on Windows systems or a shell script on UNIX/Linux/Mac OS X systems. Batch files and shell scripts offer a convenient way of executing several programs in sequence. When the first program ends, the next program begins execution. It is possible to use the argument to method exit in a batch file or shell script to determine whether other programs should execute. For more information on batch files or shell scripts, see your operating system's documentation.
Method addRecords (lines 3791) prompts the user to enter the various fields for each record or to enter the end-of-file key sequence when data entry is complete. Example 14.8 lists the key combinations for entering end-of-file for various computer systems.
|
Operating system |
Key combination |
|---|---|
|
UNIX/Linux/Mac OS X |
<return> <ctrl> d |
|
Windows |
<ctrl> z |
Line 40 creates an AccountRecord object, which will be used to store the values of the current record entered by the user. Line 42 creates a Scanner object to read input from the user at the keyboard. Lines 4448 and 5052 prompt the user for input.
Line 54 uses Scanner method hasNext to determine whether the end-of-file key combination has been entered. The loop executes until hasNext encounters the end-of-file indicators.
Lines 5962 read data from the user, storing the record information in the AccountRecord object. Each statement throws a NoSuchElementException (handled in lines 8286) if the data is in the wrong format (e.g., a string when an int is expected) or if there is no more data to input. If the account number is greater than 0 (line 64), the record's information is written to clients.txt (lines 6769) using method format. This method can perform identical formatting to the System.out.printf method used extensively in earlier chapters. This method outputs a formatted string to the output destination of the Formatter object, in this case the file clients.txt. The format string "%d %s %s %.2\n" indicates that the current record will be stored as an integer (the account number) followed by a string (the first name), another string (the last name) and a floating-point value (the balance). Each piece of information is separated from the next by a space and the double value (the balance) is output with two digits to the right of the decimal point. The data in the text file can be viewed with a text editor, or retrieved later by a program designed to read the file (). When lines 6769 execute, if the Formatter object is closed, a FormatterClosedException will be thrown (handled in lines 7781). [Note: You can also output data to a text file using class java.io.PrintWriter, which also provides method format for outputting formatted data.]
Lines 9498 declare method closeFile, which closes the Formatter and the underlying output file. Line 97 closes the object by simply calling method close. If method close is not called explicitly, the operating system normally will close the file when program execution terminates. This is an example of operating system "housekeeping."
Example 14.9 runs the program. Line 8 creates a CreateTextFile object, which is then used to open, add records to and close the file (lines 1012). The sample data for this application is shown in Example 14.10. In the sample execution for this program, the user enters information for five accounts, then enters end-of-file to signal that data entry is complete. The sample execution does not show how the data records actually appear in the file. In the next section to verify that the file has been created successfully, we present a program that reads the file and prints its contents. Because this is a text file, you can also verify the information by opening the file in a text editor.
Example 14.9. Testing the CreateTextFile class.
1 // Example 14.9: CreateTextFileTest.java
2 // Testing the CreateTextFile class.
3
4 public class CreateTextFileTest
5 {
6 public static void main( String args[] )
7 {
8 CreateTextFile application = new CreateTextFile();
9
10 application.openFile();
11 application.addRecords();
12 application.closeFile();
13 } // end main
14 } // end class CreateTextFileTest
|
|
Sample data | |||
|---|---|---|---|
|
100 |
Bob |
Jones | |
|
200 |
Steve |
Doe |
-345.67 |
|
300 |
Pam |
White | |
|
400 |
Sam |
Stone |
-42.16 |
|
500 |
Sue |
Rich |
Reading Data from a Sequential-Access Text File
Data is stored in files so that it may be retrieved for processing when needed. demonstrated how to create a file for sequential access. This section shows how to read data sequentially from a text file. In this section, we demonstrate how class Scanner can be used to input data from a file rather than the keyboard.
The application in Example 14.11 and Example 14.12 reads records from the file "clients. txt" created by the application of and displays the record contents. Line 13 of Example 14.11 declares a Scanner that will be used to retrieve input from the file.
Example 14.11. Sequential file reading using a Scanner.
1 // Example 14.11: ReadTextFile.java
2 // This program reads a text file and displays each record.
3 import java.io.File;
4 import java.io.FileNotFoundException;
5 import java.lang.IllegalStateException;
6 import java.util.NoSuchElementException;
7 import java.util.Scanner;
8
9 import com.deitel.jhtp6.ch14.AccountRecord;
10
11 public class ReadTextFile
12 {
13 private Scanner input;
14
15 // enable user to open file
16 public void openFile()
17 {
18 try
19 {
20 input = new Scanner( new File( "clients.txt" ) );
21 } // end try
22 catch ( FileNotFoundException fileNotFoundException )
23 {
24 System.err.println( "Error opening file." );
25 System.exit( 1 );
26 } // end catch
27 } // end method openFile
28
29 // read record from file
30 public void readRecords()
31 {
32 // object to be written to screen
33 AccountRecord record = new AccountRecord();
34
35 System.out.printf( "%-10s%-12s%-12s%10s\n", "Account",
36 "First Name", "Last Name", "Balance" );
37
38 try // read records from file using Scanner object
39 {
40 while ( input.hasNext() )
41 {
42 record.setAccount( input.nextInt() ); // read account number
43 record.setFirstName( input.next() ); // read first name
44 record.setLastName( input.next() ); // read last name
45 record.setBalance( input.nextDouble() ); // read balance
46
47 // display record contents
48 System.out.printf( "%-10d%-12s%-12s%10.2f\n",
49 record.getAccount(), record.getFirstName(),
50 record.getLastName(), record.getBalance() );
51 } // end while
52 } // end try
53 catch ( NoSuchElementException elementException )
54 {
55 System.err.println( "File improperly formed." );
56 input.close();
57 System.exit( 1 );
58 } // end catch
59 catch ( IllegalStateException stateException )
60 {
61 System.err.println( "Error reading from file." );
62 System.exit( 1 );
63 } // end catch
64 } // end method readRecords
65
66 // close file and terminate application
67 public void closeFile()
68 {
69 if ( input != null )
70 input.close(); // close file
71 } // end method closeFile
72 } // end class ReadTextFile
|
Example 14.12. Testing the ReadTextFile class.
1 // Example 14.12: ReadTextFileTest.java
2 // This program test class ReadTextFile.
3
4 public class ReadTextFileTest
5 {
6 public static void main( String args[] )
7 {
8 ReadTextFile application = new ReadTextFile();
9
10 application.openFile();
11 application.readRecords();
12 application.closeFile();
13 } // end main
14 } // end class ReadTextFileTest
|
Method openFile (lines 1627) opens the file for reading by instantiating a Scanner object in line 20. We pass a File object to the constructor, which specifies that the Scanner object will read from the file "clients.txt" located in the directory from which the application executes. If the file cannot be found, a FileNotFoundException occurs. The exception is handled in lines 2226.
Method readRecords (lines 3064) reads and displays records from the file. Line 33 creates AccountRecord object record to store the current record's information. Lines 3536 display headers for the columns in the application's output. Lines 4051 read data from the file until the end-of-file marker is reached (in which case, method hasNext will return false at line 40). Lines 4245 use Scanner methods nextInt, next and nexTDouble to input an integer (the account number), two strings (the first and last names) and a double value (the balance). Each record is one line of data in the file. The values are stored in object record. If the information in the file is not properly formed (e.g., there is a last name where there should be a balance), a NoSuchElementException occurs when the record is input. This exception is handled in lines 5358. If the Scanner was closed before the data was input, an IllegalStateException occurs (handled in lines 5963). If no exceptions occur, the record's information is displayed on the screen (lines 4850). Note in the format string in line 48 that the account number, first name and last name are left justified, while the balance is right justified and output with two digits of precision. Each iteration of the loop inputs one line of text from the text file, which represents one record.
Lines 6771 define method closeFile, which closes the Scanner. Method main is defined in Example 14.12, in lines 613. Line 8 creates a ReadTextFile object, which is then used to open, add records to and close the file (lines 1012).
Case Study: A Credit-Inquiry Program
To retrieve data sequentially from a file, programs normally start reading from the beginning of the file and read all the data consecutively until the desired information is found. It might be necessary to process the file sequentially several times (from the beginning of the file) during the execution of a program. Class Scanner does not provide the ability to reposition to the beginning of the file. If it is necessary to read the file again, the program must close the file and reopen it.
The program in Example 14.13Example 14.15 allows a credit manager to obtain lists of customers with zero balances (i.e., customers who do not owe any money), customers with credit balances (i.e., customers to whom the company owes money) and customers with debit balances (i.e., customers who owe the company money for goods and services received). A credit balance is a negative amount, and a debit balance is a positive amount.
Example 14.13. Enumeration for menu options.
1 // Example 14.13: 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 ZERO_BALANCE( 1 ),
8 CREDIT_BALANCE( 2 ),
9 DEBIT_BALANCE( 3 ),
10 END( 4 );
11
12 private final int value; // current menu option
13
14 MenuOption( int valueOption )
15 {
16 value = valueOption;
17 } // end MenuOptions enum constructor
18
19 public int getValue()
20 {
21 return value;
22 } // end method getValue
23 } // end enum MenuOption
|
Example 14.14. Credit-inquiry program.
1 // Example 14.14: CreditInquiry.java
2 // This program reads a file sequentially and displays the
3 // contents based on the type of account the user requests
4 // (credit balance, debit balance or zero balance).
5 import java.io.File;
6 import java.io.FileNotFoundException;
7 import java.lang.IllegalStateException;
8 import java.util.NoSuchElementException;
9 import java.util.Scanner;
10
11 import com.deitel.jhtp6.ch14.AccountRecord;
12
13 public class CreditInquiry
14 {
15 private MenuOption accountType;
16 private Scanner input;
17 private MenuOption choices[] = { MenuOption.ZERO_BALANCE,
18 MenuOption.CREDIT_BALANCE, MenuOption.DEBIT_BALANCE,
19 MenuOption.END };
20
21 // read records from file and display only records of appropriate type
22 private void readRecords()
23 {
24 // object to be written to file
25 AccountRecord record = new AccountRecord();
26
27 try // read records
28 {
29 // open file to read from beginning
30 input = new Scanner( new File( "clients.txt" ) );
31
32 while ( input.hasNext() ) // input the values from the file
33 {
34 record.setAccount( input.nextInt() ); // read account number
35 record.setFirstName( input.next() ); // read first name
36 record.setLastName( input.next() ); // read last name
37 record.setBalance( input.nextDouble() ); // read balance
38
39 // if proper acount type, display record
40 if ( shouldDisplay( record.getBalance() ) )
41 System.out.printf( "%-10d%-12s%-12s%10.2f\n",
42 record.getAccount(), record.getFirstName(),
43 record.getLastName(), record.getBalance() );
44 } // end while
45 } // end try
46 catch ( NoSuchElementException elementException )
47 {
48 System.err.println( "File improperly formed." );
49 input.close();
50 System.exit( 1 );
51 } // end catch
52 catch ( IllegalStateException stateException )
53 {
54 System.err.println( "Error reading from file." );
55 System.exit( 1 );
56 } // end catch
57 catch ( FileNotFoundException fileNotFoundException )
58 {
59 System.err.println( "File cannot be found." );
60 System.exit( 1 );
61 } // end catch
62 finally
63 {
64 if ( input != null )
65 input.close(); // close the Scanner and the file
66 } // end finally
67 } // end method readRecords
68
69 // use record type to determine if record should be displayed
70 private boolean shouldDisplay( double balance )
71 {
72 if ( ( accountType == MenuOption.CREDIT_BALANCE )
73 && ( balance < 0 ) )
74 return true;
75
76 else if ( ( accountType == MenuOption.DEBIT_BALANCE )
77 && ( balance > 0 ) )
78 return true;
79
80 else if ( ( accountType == MenuOption.ZERO_BALANCE )
81 && ( balance == 0 ) )
82 return true;
83
84 return false;
85 } // end method shouldDisplay
86
87 // obtain request from user
88 private MenuOption getRequest()
89 {
90 Scanner textIn = new Scanner( System.in );
91 int request = 1 ;
92
93 // display request options
94 System.out.printf( "\n%s\n%s\n%s\n%s\n%s\n",
95 "Enter request", " 1 - List accounts with zero balances",
96 " 2 - List accounts with credit balances",
97 " 3 - List accounts with debit balances", " 4 - End of run" );
98
99 try // attempt to input menu choice
100 {
101 do // input user request
102 {
103 System.out.print( "\n? " );
104 request = textIn.nextInt();
105 } while ( ( request < 1 ) || ( request > 4 ) );
106 } // end try
107 catch ( NoSuchElementException elementException )
108 {
109 System.err.println( "Invalid input." );
110 System.exit( 1 );
111 } // end catch
112
113 return choices[ request - 1 ]; // return enum value for option
114 } // end method getRequest
115
116 public void processRequests()
117 {
118 // get user's request (e.g., zero, credit or debit balance)
119 accountType = getRequest();
120
121 while ( accountType != MenuOption.END )
122 {
123 switch ( accountType )
124 {
125 case ZERO_BALANCE:
126 System.out.println( "\nAccounts with zero balances:\n" );
127 break;
128 case CREDIT_BALANCE:
129 System.out.println( "\nAccounts with credit balances:\n" );
130 break ;
131 case DEBIT_BALANCE:
132 System.out.println( "\nAccounts with debit balances:\n" );
133 break;
134 } // end switch
135
136 readRecords();
137 accountType = getRequest();
138 } // end while
139 } // end method processRequests
140 } // end class CreditInquiry
|
Example 14.15. Testing the CreditInquiry class.
1 // Example 14.15: CreditInquiryTest.java
2 // This program tests class CreditInquiry.
3
4 public class CreditInquiryTest
5 {
6 public static void main( String args[] )
7 {
8 CreditInquiry application = new CreditInquiry();
9 application.processRequests();
10 } // end main
11 } // end class CreditInquiryTest
|
We begin by creating an enum type (Example 14.13) to define the different menu options the user will have. The options and their values are listed in lines 710. Method getValue (lines 1922) retrieves the value of a specific enum constant.
Example 14.14 contains the functionality for the credit-inquiry program, and Example 14.15 contains the main method that executes the program. The program displays a text menu and allows the credit manager to enter one of three options to obtain credit information. Option 1 (ZERO_BALANCE) produces a list of accounts with zero balances. Option 2 (CREDIT_BALANCE) produces a list of accounts with credit balances. Option 3 (DEBIT_BALANCE) produces a list of accounts with debit balances. Option 4 (END) terminates program execution. A sample output is shown in Example 14.16.
Example 14.16. Sample output of the credit-inquiry program in Example 14.15.
|
The record information is collected by reading through the entire file and determining whether each record satisfies the criteria for the account type selected by the credit manager. Method processRequests (lines 116139 of Example 14.14) calls method getrequest to display the menu options (line 119) and stores the result in MenuOption variable accountType. Note that getrequest TRanslates the number typed by the user into a MenuOption by using the number to select a MenuOption from array choices. Lines 121138 loop until the user specifies that the program should terminate. The switch statement in lines 123134 displays a header for the current set of records to be output to the screen. Line 136 calls method readRecords (lines 2267), which loops through the file and reads every record.
Line 30 of method readRecords opens the file for reading with a Scanner. Note that the file will be opened for reading with a new Scanner object each time this method is called, so that we can again read from the beginning of the file. Lines 3437 read a record. Line 40 calls method shouldDisplay (lines 7085) to determine whether the current record satisfies the account type requested. If shouldDisplay returns TRue, the program displays the account information. When the end-of-file marker is reached, the loop terminates and line 65 calls the Scanner's close method to close the Scanner and the file. Notice that this occurs in a finally block, which will execute whether or not the file was successfully read. Once all the records have been read, control returns to method processRequests and geTRequest is again called (line 137) to retrieve the user's next menu option. Example 14.15 contains method main, and calls method processRequests in line 9.
Updating Sequential-Access Files
The data in many sequential files cannot be modified without the risk of destroying other data in the file. For example, if the name "White" needed to be changed to "Worthington," the old name cannot simply be overwritten because the new name requires more space. The record for White was written to the file as
300 Pam White 0.00
If the record is rewritten beginning at the same location in the file using the new name, the record would be
300 Pam Worthington 0.00
The new record is larger (has more characters) than the original record. The characters beyond the second "o" in "Worthington" would overwrite the beginning of the next sequential record in the file. The problem here is that fields in a text fileand hence recordscan vary in size. For example, 7, 14,117, 2074 and 27383 are all ints stored in the same number of bytes (4) internally, but they are different-sized fields when displayed on the screen or written to a file as text.
Therefore, records in a sequential-access file are not usually updated in place. Instead, the entire file is usually rewritten. To make the preceding name change, the records before 300 Pam White 0.00 in a sequential-access file would be copied to a new file, the new record (which can be of a different size than the one it replaces) would be written and the records after 300 Pam White 0.00 would be copied to the new file. It is uneconomical just to update one record, but reasonable if a substantial portion of the records needs to be updated.