Question

Find the error in each block of code and show how to correct it. a) Assume that account, company and amount are declared. Object0utputStream outputStream; outputStream.writeInt( account ); outputStream.writeChars( company ); outputStream.writeDouble ( amount ); b) The following statements should read a record from the file "payables.txt". The Scanner variable inPayable should be used to refer to this file. Scanner inPayable = new Scanner( new File( "payables.txt" ) ); PayablesRecord record = ( PayablesRecord ) inPayable.readobject();

Short answer

Initialize `ObjectOutputStream` correctly and use `ObjectInputStream` for reading objects.

Step-by-step solution

Identify the Error in Code Block (a)

In code block (a), the error is that the `ObjectOutputStream` object `outputStream` is not initialized before it is used. The stream must be associated with an underlying byte stream, such as a `FileOutputStream`.

Correct Code Block (a)

To correct the code, initialize the `ObjectOutputStream` with a `FileOutputStream`. For example: ```java outputStream = new ObjectOutputStream(new FileOutputStream("output.dat")); outputStream.writeInt(account); outputStream.writeChars(company); outputStream.writeDouble(amount); ``` This will attach the object output stream to a file named "output.dat".

Identify the Error in Code Block (b)

In code block (b), the error is that the `Scanner` class does not have a `readObject()` method. This method is used for object input streams, not scanners.

Correct Code Block (b)

To correct this, replace the `Scanner` with an `ObjectInputStream`, which does support `readObject()`. Here is the corrected code: ```java ObjectInputStream inPayable = new ObjectInputStream(new FileInputStream("payables.txt")); PayablesRecord record = (PayablesRecord) inPayable.readObject(); ``` Ensure that the required class imports are included, and handle exceptions such as `ClassNotFoundException` and `IOException`.

Key concepts

ObjectOutputStream

In Java Input/Output operations, `ObjectOutputStream` plays a crucial role in serializing objects. Serialization makes it possible to write an object to a file, so it can be reconstructed later.
For the `ObjectOutputStream` to work, it needs to be initialized properly.

• Always connect it with a `FileOutputStream` to specify the file destination.
• Use the `writeObject()` method to save objects, but `writeInt()` or `writeChars()` can also be used for primitives and strings.
• Remember to close your stream with `close()` method to release system resources.

This stream makes it easy to transfer objects into files, making it incredibly useful for preserving object states between program runs.

FileOutputStream

`FileOutputStream` is a byte stream class used in Java for writing streams of raw bytes to a file. This stream is particularly useful for writing binary data.
Connecting `FileOutputStream` with an `ObjectOutputStream` allows serialization of objects to a file. Here are some critical features:

• It directs the bytes to a specified file, for example, "output.dat".
• Using `write()` method, you can write data as bytes directly into the file.
• Always handle exceptions like `IOException` to manage file access issues safely.

In essence, `FileOutputStream` is like the road that guides data bytes from your program to an external file.

ObjectInputStream

`ObjectInputStream` is the counterpart to `ObjectOutputStream`, enabling the reading and deserialization of objects that have been written to an output stream. When you want to access the previously stored data, this class comes into play.

• You must link it with a `FileInputStream` to specify the input source file.
• The `readObject()` method reads bytes and converts them back into the original object form.
• Make sure to handle exceptions like `IOException` and `ClassNotFoundException` which occur during deserialization.

In Java, `ObjectInputStream` makes retrieving data stored as objects a seamless process, simplifying data restoration and usage.

Java I/O streams

Java I/O (Input/Output) streams serve as a powerful abstraction for reading from and writing to byte and character streams. These streams simplify data processing by handling I/O through mechanisms like files, network sockets, or byte arrays.
Some key points about Java I/O streams include:

• Character Streams deal with reading/writing of character-based data, while Byte Streams handle binary data.
• Using `BufferedReader` or `BufferedOutputStream` can increase efficiency by buffering data.
• Java streams use various mechanisms like `try-with-resources` to enforce automatic resource management and exception handling.

Java's I/O streams systematically manage data flow, freeing developers to focus more on application logic and less on intricate details.