Question

Complete the following tasks, assuming that each applies to the same program: a) Write a statement that opens file "oldmast.ser" for input-use objectInputstream variable in01dMaster to wrap a FileInputStream object. b) Write a statement that opens file "trans.ser" for input-use ObjectInputStream variable inTransaction to wrap a FileInputStream object. c) Write a statement that opens file "newmast.ser" for output (and creation)-use \(0 \mathrm{b}-\) ject0utputStream variable outNewMaster to wrap a File0utputStream. d) Write a statement that reads a record from the file "oldmast.ser". The record is an object of class AccountRecordSerializable- use ObjectInputStream variable in01dMaster. Assume class AccountRecordSerializable is the same as the AccountRecordSerializable class in Fig. 14.17 e) Write a statement that reads a record from the file "trans.ser". The record is an object of class TransactionRecord - use ObjectInputStream variable inTransaction. f) Write a statement that outputs a record to the file "newmast.ser". The record is an object of type AccountRecordSerializable-use Object0utputStream variable outNewMaster.

Short answer

Open files using FileInputStream and ObjectInputStream for reading, and FileOutputStream with ObjectOutputStream for writing.

Step-by-step solution

Opening 'oldmast.ser' for Input

To open 'oldmast.ser' for input and wrap it within an ObjectInputStream, we first create a FileInputStream. Then, we wrap it with an ObjectInputStream called 'in01dMaster'. ```java FileInputStream fisOldMaster = new FileInputStream("oldmast.ser"); ObjectInputStream in01dMaster = new ObjectInputStream(fisOldMaster); ```

Opening 'trans.ser' for Input

Similarly, for opening the file 'trans.ser', we create a FileInputStream and wrap it using an ObjectInputStream named 'inTransaction'. ```java FileInputStream fisTransaction = new FileInputStream("trans.ser"); ObjectInputStream inTransaction = new ObjectInputStream(fisTransaction); ```

Opening 'newmast.ser' for Output

To open 'newmast.ser' for output, we create a FileOutputStream and then wrap it with an ObjectOutputStream named 'outNewMaster'. This allows us to create and write objects to the file. ```java FileOutputStream fosNewMaster = new FileOutputStream("newmast.ser"); ObjectOutputStream outNewMaster = new ObjectOutputStream(fosNewMaster); ```

Reading a Record from 'oldmast.ser'

To read a record from 'oldmast.ser', which contains AccountRecordSerializable objects, we use the readObject method of the ObjectInputStream 'in01dMaster'. ```java AccountRecordSerializable accountRecord = (AccountRecordSerializable) in01dMaster.readObject(); ```

Reading a Record from 'trans.ser'

To read a TransactionRecord object from 'trans.ser', we similarly use the readObject method of 'inTransaction'. ```java TransactionRecord transactionRecord = (TransactionRecord) inTransaction.readObject(); ```

Writing a Record to 'newmast.ser'

To write an AccountRecordSerializable object to 'newmast.ser', we use the writeObject method of the ObjectOutputStream 'outNewMaster'. ```java outNewMaster.writeObject(accountRecord); ```

Key concepts

ObjectInputStream

The `ObjectInputStream` class in Java is a fundamental tool for reading serialized objects from files. When dealing with file operations in Java, especially when you want to read objects, `ObjectInputStream` becomes indispensable. It transforms data in a stream form back into a meaningful object structure. To use `ObjectInputStream`, you'll typically use it in combination with a `FileInputStream`. This means that the data, which is often stored in a file, is read as a sequence of bytes. The `FileInputStream` reads this sequence, and the `ObjectInputStream` then interprets these bytes as an object.

It’s essential to remember that `ObjectInputStream` works with files created through the `ObjectOutputStream`. This ensures that the format and the structure of the data are compatible. Here’s a simple breakdown:

• Open a file using `FileInputStream`.


• Wrap this stream using `ObjectInputStream`.


• Utilize the `readObject()` method to retrieve objects from the file.

This process allows seamless reading of complex objects stored within files, adhering to Java’s object serialization mechanism.

FileInputStream

`FileInputStream` is a base tool for reading data streams from file sources in Java. It directly deals with the raw input of bytes from a file and is pivotal for various I/O operations. Imagine you have a file full of data that you need to process; this is where `FileInputStream` comes in. It reads data byte by byte, allowing programs to process it further. You often wrap it in other input classes, like `ObjectInputStream`, to handle more complex data types like objects. To use `FileInputStream`, you open a connection to the file you wish to read.

• Initialize using: `FileInputStream fileInput = new FileInputStream("filename.ser")`.
• Ensure the file exists, as it throws an exception if the file is missing.
• Close the stream after reading to free system resources.

Given its importance, understanding `FileInputStream` is crucial for anyone involved in file manipulations, making it a cornerstone in Java’s file I/O operations.

ObjectOutputStream

The `ObjectOutputStream` class is used in Java to facilitate the serialization of objects into a file. This class makes it possible to write objects to a file in a form that can be later deserialized back into objects. Serialization in Java is a process where an object's state is transformed into a byte stream. `ObjectOutputStream` aids in carrying out this task by taking an object and writing its state, serialized, into a file. Here’s how you can work with `ObjectOutputStream`:

• Open a file using a `FileOutputStream`.


• Wrap this stream using `ObjectOutputStream`.


• Use `writeObject(object)` to serialize the object and send it to the file.

One of the essential practices while using `ObjectOutputStream` is ensuring that the class structure of the object is maintained. Alterations might lead to invalid data during deserialization.

Serialization in Java

Serialization in Java is a technique used to convert an object into a byte stream, thus making it easy to store an object or transmit it over a network. This technique is crucial for Java developers when data needs to be persisted or shared. Serialization ensures that all the state of an object, except for the transient and static fields, is captured and stored. This is achieved by implementing the `Serializable` interface, which marks a class as serializable. Key points about serialization:

• The `Serializable` interface is marker-based and does not contain any methods.
• Use `ObjectOutputStream` to serialize an object to a file.


• Deserialization, the reverse process, reads back these bytes to recreate the object, done using `ObjectInputStream`.


• Always maintain the version of a class using `serialVersionUID` to handle deserialization compatibility.

Serialization is extremely beneficial when running object communication in distributed systems or storing application states efficiently.