Question

Complete the following tasks, assuming that each applies to the same program: a) Write a statement that opens file "oldmast.txt" for input-use Scanner variable in01 dMaster. b) Write a statement that opens file "trans.txt" for input-use Scanner variable inTransaction. c) Write a statement that opens file "newmast. txt" for output (and creation)-use formatter variable outNewMaster. d) Write the statements needed to read a record from the file "oldmast. txt". Use the data to create an object of class AccountRecord-use Scanner variable in01dMaster. Assume that class AccountRecord is the same as the AccountRecord class in Fig. 17.4. e) Write the statements needed to read a record from the file "trans. txt". The record is an object of class TransactionRecord-use Scanner variable inTransaction. Assume that class TransactionRecord contains method setAccount (which takes an int) to set the account number and method setAmount (which takes a double) to set the amount of the transaction. Hrite a statement that outputs a record to the file "newmast. txt". The record is an object of type AccountRecord-use Formatter variable outNewMaster.

Short answer

To handle I/O operations, open input files with Scanner objects and the output file with a Formatter object; use these objects for reading from and writing to files accordingly.

Step-by-step solution

Opening oldmast.txt for input

To open the file 'oldmast.txt' for input, create a new Scanner object linked to the file. This can be done by passing the file's path to the Scanner constructor inside a try-catch block to handle any potential FileNotFoundExceptions.

Opening trans.txt for input

Similarly, to open the file 'trans.txt' for input, create a new Scanner object and link it to the file by passing the file's path to the Scanner constructor, wrapped in a try-catch block to manage exceptions.

Opening newmast.txt for output

To open 'newmast.txt' for output, create a new Formatter object. Pass the file's path to the Formatter constructor, which also should be wrapped in a try-catch block to handle exceptions such as a SecurityException or FileNotFoundException.

Reading a record from oldmast.txt

Use the Scanner object in01dMaster to read the data from 'oldmast.txt' and create a new AccountRecord object with that data. A potential method in the AccountRecord class could be used for setting the data directly from the Scanner object.

Reading a record from trans.txt

Use the Scanner object inTransaction to read data from 'trans.txt'. Create a new TransactionRecord object and call its setAccount and setAmount methods to set the account number and transaction amount, respectively, which are read from the file.

Outputting a record to newmast.txt

Use the Formatter object outNewMaster to output data to 'newmast.txt'. Create an AccountRecord object with the data to be outputted and use the Formatter to write this data to the new file.

Key concepts

Scanner class

The Scanner class in Java is a simple text scanner which can parse primitive types and strings using regular expressions. It's particularly useful for reading data from various input sources like files, input streams, or even strings. When dealing with file handling, as in our exercise where we're opening 'oldmast.txt' and 'trans.txt', the Scanner class provides a convenient way to read in text.

To open a file for reading, you create a new Scanner instance and pass the file name to its constructor. Here's a basic example:

Formatter class

In contrast to the Scanner class which is used for reading, the Formatter class is used for writing formatted data to files, streams, or strings. It works somewhat like printf in C, allowing you to create a formatted string with placeholders that will be replaced by variable values. This utility makes it ideal for creating files with structured data, as demonstrated in our exercise with 'newmast.txt'.

To write to a file using Formatter, you instantiate it with the file's name, and then you can use the format() method to write strings into the file. Always make sure to handle exceptions, as file operations can fail for various reasons such as file not found or access permissions.

Try-catch block

A try-catch block in Java is crucial for handling exceptions, which are errors that occur during the execution of a program. File operations often lead to exceptions, like FileNotFoundException or SecurityException, and they must be handled gracefully. The try-catch block allows you to 'try' a block of code and 'catch' any exceptions that are thrown.

In file handling, we use this mechanism to attempt to open, read, and write files. If an exception occurs, the catch block is executed, which typically contains code to handle the error, such as informing the user or attempting an alternative action.

Reading and writing files

Reading and writing files in Java are common operations that require careful consideration to ensure data integrity and handle possible exceptions. When reading a file, you usually open a stream to the file, read its content, and then close the stream. The same goes for writing, where you open a stream, write data to it, and then close the stream.

These operations are fundamental for persistence, allowing applications to maintain state or to exchange information. In the context of the exercise, reading from 'oldmast.txt' and 'trans.txt' and writing to 'newmast.txt' involve these core principles, using a combination of Scanner and Formatter objects wrapped in try-catch blocks to safely perform file I/O.