Chapter 8 ■ Java I/O Fundamentals

Now let’s get back to the program and see how it works. The program writes to the data file with a hard-coded file named temp.data in the current directory from which the program is run. This program first writes the data, so it opens the file as an output stream. What does the following statement within the first try block mean?

DataOutputStream dos = new DataOutputStream(new FileOutputStream("temp.data"))

You can directly perform binary I/O with OutputStream and its derived class of FileOutputStream, but to process data formats such as primitive type values, you need to use DataOutputStream, which acts as a wrapper over the underlying FileOutputStream. So, you use the DataOutputStream here, which provides methods such as writeByte and writeShort. You use these methods to write the primitive type values 0 to 9 into the data file. Note that you don’t have to close the streams explicitly since you opened the DataOutputStream in a try-with-resources statement, hence the close() method on dos reference will automatically be invoked. The close() method also flushes the underlying stream; this close() method will also close the underlying reference to the FileOutputStream.

Once the file is written, you read the data file in a similar way. You open a FileInputStream and wrap it with a DataInputStream. You read the data from the stream and print it in console. You used format specifiers such as %d (which is a common format specifier for printing integral values like byte, short, int, or long) as well as %f, %g, or %e specifiers for printing floating point values of type float or double; %n is for printing a newline character.

In this program, you wrote and read primitive type values. What about reference type objects, such as Objects, Maps, etc.? Reading and writing objects is achieved through object streams, which we’ll discuss now.

Writing to and Reading from Object Streams: Serialization

The classes ObjectInputStream and ObjectOutputStream support reading and writing Java objects that you use in the program. For example, if you are creating an online e-commerce web site for making purchases, you can choose to write objects such as customers, purchase requests made, etc., to an RDBMS (we’ll cover JDBC in Chapter 10), or alternatively, store the objects directly in flat files. In such cases, you must know how to read or write objects into streams.

Let’s introduce some terms related to this topic before we go ahead. The process of converting objects in memory into sequence of bytes is known as serialization. The mechanism of storing objects in memory into files is known as persistence. Often these concepts are clubbed together and referred as serialization only.

Listing 8-9 contains a simple example of writing the contents of a Map data structure to a file and reading it back to illustrate the use of the classes ObjectInputStream and ObjectOutputStream to read or write objects. You store the details of the last three US presidents in this map.

Listing 8-9.  ObjectStreamExample.java

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;

import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.HashMap;

import java.util.Map;

//A simple class to illustrate object streams: fill a data structure, write it to a

//temporary file and read it back and print the read data structure

class ObjectStreamExample {

public static void main(String []args) {

Map<String, String> presidentsOfUS = new HashMap<>(); presidentsOfUS.put("Barack Obama", "2009 to --, Democratic Party, 56th term");

presidentsOfUS.put("George W. Bush", "2001 to 2009, Republican Party, 54th and 55th terms");

242

Chapter 8 ■ Java I/O Fundamentals

presidentsOfUS.put("Bill Clinton", "1993 to 2001, Democratic Party, 52nd and 53rd terms");

try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.data"))) {

oos.writeObject(presidentsOfUS); } catch(FileNotFoundException fnfe) {

System.err.println("cannot create a file with the given file name "); } catch(IOException ioe) {

System.err.println("an I/O error occurred while processing the file"); } // the ObjectOutputStream will auto-close, so don't have to worry about it

try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.data"))) {

Object obj = ois.readObject();

// first check if obj is of type Map if(obj != null && obj instanceof Map) {

Map<String, String> presidents = (Map<String, String>) obj; System.out.println("President name \t Description \n"); for(Map.Entry<String, String> president : presidents.entrySet()) {

System.out.printf("%s \t %s %n", president.getKey(),

president.getValue());

}

}

} catch(FileNotFoundException fnfe) {

System.err.println("cannot create a file with the given file name "); } catch(IOException ioe) {

System.err.println("an I/O error occurred while processing the file"); } catch(ClassNotFoundException cnfe) {

System.err.println("cannot recognize the class of the object - is the file

corrupted?");

}

}

}

Before discussing how the program works, let’s check if it works.

D:\> java ObjectStreamExample

The serialization process converts contents of the objects in memory with the description of the contents (known as metadata). When the object has references to other objects, the serialization mechanism also includes them as part of the serialized bytes. If you try to open the file in which the object is persisted, you cannot read these serialized and then persisted objects. For example, if you try to read the object.data file, you’ll see numerous unreadable characters.

Now, let’s get back to the program and see how it works. In this program, you fill the HashMap container with details of last three US presidents. Then, you open an output stream as follows:

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.data"))

243

Chapter 8 ■ Java I/O Fundamentals

The FileOutputStream opens a temporary file named object.data in the current directory. The ObjectOutputStream is a wrapper over this underlying FileOutputStream. Inside this try-with-resources block, you’ve only one statement, oos.writeObject(presidentsOfUS), which writes the object to the object.data file.

Reading the object requires a bit more work than writing the object. The readObject() method in ObjectInputStream returns an Object type. You need to convert it back to Map<String, String>. Before downcasting it to this specific type, you check if the obj is of type Map. Note that you don’t have to check if it’s Map<String, String> because these generic types are lost in the process known as type erasure (see Chapter 6 for a discussion on this topic). Once the downcast succeeds, you can read the values of the contents in this object.

Serialization: Some More Details

It is relevant for us to elaborate more on the topic of serialization. As illustrated in the last section, serialization is a process of converting an object to a sequence of bytes. You can write a serialized object to a file as you did in last example or you can put it on a socket to send it over the network.

The last example illustrated how to write objects to streams; that is nothing but serialization with persistence. In the last example, you created an instance of HashMap and then serialized and deserialized it. What if you want to serialize an object of a class you created (instead of serializing HashMap). Well, you can serialize objects of all classes provided the classes implement the Serializable interface. In other words, a class is not serializable by default; you need to implement the Serializable interface to make it serializable. In the last example, the HashMap class also implements the Serializable interface.

You need to implement the Serializable interface in a class if you want to make the objects of the class serializable.

Now, let’s assume that you want to serialize an object that contains an unserializable class member (say Thread or Socket). Or, think of a situation where you do not want to serialize a member variable. For such situations, Java offers a keyword known as transient. You can declare a member variable as transient and that variable will not be serialized by the JVM. Let’s look at an example to understand it better. Assume that you have an USPresident class that stores name of a US president, his period, and term of office. You want to serialize the objects of this class, so this class implements the Serializable interface. However, you do not want to serialize one field, say term. Listing 8-10 shows how to achieve this.

Listing 8-10.  TransientSerialization.java

import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException;

import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable;

class USPresident implements Serializable{

private static final long serialVersionUID = 1L;

@Override

public String toString() {

return "US President [name=" + name + ", period=" + period + ", term=" + term + "]";

}

244

Chapter 8 ■ Java I/O Fundamentals

public USPresident(String name, String period, String term) { this.name = name;

this.period = period; this.term = term;

}

private String name; private String period;

private transient String term;

}

class TransientSerialization {

public static void main(String []args) {

USPresident usPresident = new USPresident("Barack Obama", "2009 to --", "56th term"); System.out.println(usPresident);

//Serialize the object

try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("USPresident.data"))){

oos.writeObject(usPresident);

}

catch(FileNotFoundException fnfe) {

System.err.println("cannot create a file with the given file name "); } catch(IOException ioe) {

System.err.println("an I/O error occurred while processing the file"); } // the ObjectOutputStream will auto-close, so don't have to worry about it

//De-serialize the object

try(ObjectInputStream ois = new ObjectInputStream(new FileInputStream("USPresident.data"))){

Object obj = ois.readObject();

if(obj != null && obj instanceof USPresident){ USPresident presidentOfUS = (USPresident)obj; System.out.println(presidentOfUS);

}

}catch(FileNotFoundException fnfe) {

System.err.println("cannot create a file with the given file name "); } catch(IOException ioe) {

System.err.println("an I/O error occurred while processing the file"); } catch(ClassNotFoundException cnfe) {

System.err.println("cannot recognize the class of the object - is the

file corrupted?");

}

}

}

It prints the following:

US President [name=Barack Obama, period=2009 to --, term=56th term] US President [name=Barack Obama, period=2009 to --, term=null]

This program is very simple. First, you create an instance of a USPresident class with all required fields. Then, you print the contents of the object. After that, you serialize the object and then deserialize it. You print the contents of

245