chap 9 : i/o and streams (scjp/ocjp)

1

I/O and Streams

Ben Abdallah Helmi Architect J2EE

2

Text, UTF, and Unicode

• Programs may use UTF(UTF stands for UCS Transformation Format, and UCS in turn stands for Universal Character Set. to read and write Unicode.

• Programs may use readers and writers to convert between internal Unicode and external8-bit encodings.


3

File Input and Output

• Java’s java.io.File and java.io.RandomAccessFile classes provide functionality for navigating the local file system, describing files and directories, and accessing files in non-sequential order. (Accessing files sequentially is done with streams, readers, and writers, which are described later in this chapter.) All file access begins with the creation of an instance of one of these classes.

• File(String pathname);

• It is important to know that constructing an instance of File does not create a file on the local file system. Calling the constructor simply creates an instance that encapsulates the specified string.


4

There are two other versions of the File constructor: File(String dir, String subpath); File(File dir, String subpath); 1.File f1 =2. new File(“/tmp”, “xyz”); // Assume /tmp is a dir3. File f2 = new File(f1, “Xyz.java”); 1. File f1 =2. new File(“C:\\a”); // Assume C:\a is a dir3. File f2 = new File(f1, “Xyz.java”);Eventually, if you try to access a file via a File instance that uses

the wrong semantics, you’ll get a FileNotFoundExceptionBen Abdallah Helmi Architect J2EE

5

The major methods that support navigation are as follows:

• boolean exists() Returns true if the file or directory exists; otherwise returns false .

• String getAbsolutePath() Returns the absolute (that is, not relative) path of the file or directory.

• String getCanonicalPath() Returns the canonical path of the file or directory. This method is similar to getAbsolutePath() , but the symbols . And .. are resolved.

• String getName() Returns the name of the file or directory. The name is the last element of the path.

• String getParent() Returns the name of the directory that contains the File .• boolean isDirectory() Returns true if the File object describes a directory that

exists on the file system.• boolean isFile() Returns true if the File object describes a file that exists on

the file system.• String[] list() Returns an array containing the names of the files and

directories within the File instance, which File must describe a directory, not a file.Ben Abdallah Helmi Architect

J2EE

6

Some non-navigation methods are as follows:

• boolean canRead() Returns true if the file or directory may be read.• boolean canWrite() Returns true if the file or directory may be

modified.• boolean createNewFile()Creates a new empty disk file as described

by the current object, if such a file does not already exist. Returns true if the file was created.

• boolean delete() Attempts to delete the file or directory.• long length() Returns the length of the file.• boolean mkdir() Attempts to create a directory whose path is

described by the current instance of File• boolean renameTo(File newname ) Renames the file or directory.

This method returns true if the renaming succeeded; otherwise it returns false

.Ben Abdallah Helmi Architect J2EE

7

here is a summary of the key points concerning the File class:

• An instance of File describes a file or directory.• The file or directory might or might not exist.• Constructing/garbage collecting an instance of File has

no effect on the local file system.


8

The RandomAccess File Class

• This class presents a model of files that is incompatible with the stream/reader/writer model.

• With a random-access file, you can seek to a desired position within a file and then read or write a desired amount of data. The RandomAccessFile class provides methods that support seeking, reading, and writing.


9

• The mode string should be either “r” or “rw”. Use “r” to open the file for reading only, and use “rw” to open for both reading and writing. In revision 5.0 two more modes were introduced:

• “rws” and “rwd.” With a mode of “rws” the file is opened for reading and writing, and any changes to the file’s content or metadata take place immediately. (Metadata is all the data that describes a file: its permission modes, ownership, last-modified time, etc.) With the “rwd” mode, the file is opened for reading and writing, and changes to the files content, but not its metadata, take place immediately.


10

1. File file = new File(path);2. if (!file.isFile() ||3. !file.canRead() ||4. !file.canWrite())5. throw new IOException();6. RandomAccessFile raf = new RandomAccessFile(file, “rw”);• When the named file does not exist, constructing a

RandomAccessFile is different from constructing an ordinary File. In this situation, if the random-access file is constructed in read-only mode, a FileNotFoundException is thrown. If the random-access file is constructed in readwrite mode, then a zero-length file is created.

• Java’s random-access files support only seeking relative to the beginning of the file but methods exist that report the current position and the length of the file, so you can effectively perform the other kinds of seeking as long as you are willing to do the arithmetic.


11

The methods that support seeking are as follows:

• long getFilePointer() throws IOException Returns the current position within the file, in bytes. Subsequent reading and writing will take place starting at this position.

• long length() throws IOException Returns the length of the file, in bytes.

• void seek(long position) throws IOException Sets the current position within the file, in bytes. Subsequent reading and writing will take place starting at this position. Files start at position 0.


12

import java.io.*;class GeneralRAF extends RandomAccessFile {public GeneralRAF(File path, String mode)throws IOException {super(path, mode);}public GeneralRAF(String path, String mode)throws IOException {super(path, mode);}public void seekFromEnd(long offset)throws IOException {seek(length() - offset);}public void seekFromCurrent(long offset)throws IOException {seek(getFilePointer() + offset);}}


13

int read() throws IOException Returns the next byte from the file (stored in the low-order eight bits of an int) or -1 if at the end of the file.

int read(byte dest[]) throws IOException Attempts to read enough bytes to fill array dest[]. It returns the number of bytes read, or -1 if at the end of the file.

int read(byte dest[], int offset, int len) throws IOException Attempts to read len bytes into array dest[], starting at offset. It returns the number of bytes read, or -1 if at the end of the file.

void write(int b) throws IOException Writes the low-order byte of b.void write(byte b[]) throws IOException Writes all of byte array b[].void write(byte b[], int offset, int len) throws IOException Writes len

bytes from byte array b[], starting at offset.When a random-access file is no longer needed, it should be closed:void close() throws IOExceptionBen Abdallah Helmi Architect

J2EE

14

To summarize, random-access files offer the following functionality:

• Seeking to any position within a file• Reading and writing single or multiple bytes• Reading and writing groups of bytes, treated as higher-

level data types• Closing


15

Streams, Readers, and Writers

• Java’s stream, reader, and writer classes view input and output as ordered sequences of bytes.

• You have already seen how the RandomAccessFile class allows you to read and write all of Java’s primitive data types. The readInt() method, for example, reads four bytes from a file, pieces them together, and returns an int. Java’s general I/O classes provide a similar structured approach.

• The stream, reader, and writer classes are not very complicated. The easiest way to review them is to begin with the low-level streams.


16

Low-Level Streams

• The two most common file input stream constructors are• FileInputStream(String pathname)• FileInputStream(File file)• int read() throws IOException Returns the next byte from the file (stored in the low-

order eight bits of an int) or -1 if at the end of the file.• int read(byte dest[]) throws IOException Attempts to read enough bytes to fill array

dest[]. It returns the number of bytes read or -1 if at the end of the file.• int read(byte dest[], int offset, int len) throws IOException Attempts to read len bytes

into array dest[], starting at offset. It returns the number of bytes read or -1 if at the end of the file

• int available() throws IOException Returns the number of bytes that can be read without blocking.

• void close() throws IOException Releases non-memory system resources associated with the file. A file input stream should always be closed when no longer needed.

• long s k ip(long n b y tes) throws IOException Attempts to read and discard nbytes bytes. Returns the number of bytes actually skipped.


17

byte b;byte bytes[] = new byte[100];byte morebytes[] = new byte[50];try {FileInputStream fis = new FileInputStream(“fname”);b = (byte) fis.read(); // Single bytefis.read(bytes); // Fill the arrayfis.read(morebytes, 0, 20); // 1st 20 elementsfis.close();}catch (IOException e) {}


18

• FileOutputStream(String pathname)• FileOutputStream(File file)• void write(int b) throws IOException Writes the low-order

byte of b.• void write(byte bytes[]) throws IOException Writes all

members of byte array bytes[].• void write(byte bytes[], int offset, int len) throws

IOException Writes len bytes from array bytes[], starting at offset.


19

In addition to the two classes described earlier, the java.io pack age has other low-level input and output stream classes:

• InputStream and OutputStream These are the superclasses of the other low-level stream classes. They can be used for reading and writing network sockets.

• ByteArrayInputStream and ByteArrayOutputStream These classes read and write arrays of bytes. Byte arrays are certainly not hardware I/O devices, but the classes are useful when you want to process or create sequences of bytes.

• PipedInputStream and PipedOutputStream These classes provide a mechanism for synchronized communication between threads.


20

High-Level Streams

java supports high-level I/O with high-level streams. The most common of extend from the superclasses FilterInputStream and FilterOutputStream. High-le vel inp ut streams do not re a d from inpu t devices s uch a s files or sockets; rather, they read from other streams. H i gh-level outpu t streams do not write to output devices but to other streams.

A good example of a high-level input stream is the data input stream. This class has only one constructor:

D ataInputStream(InputStream instream) The constructor requires you to pass in an input stream. This

instance might be a file input stream (because FileInputStream extends InputStream), an input stream from a socket, or any other kind of input stream.


21

The commonly used input methods of the DataInputStreamclass are as follows:boolean read Boolean() throws IOExceptionbyte read Byte() throws IOExceptionchar readChar () throws IOExceptiondouble read Double () throws IOExceptionfloat readFloat () throws IOExceptionint readInt() throws IOExceptionlong readLong() throws IOExceptionshort readShort() throws IOExceptionString read UTF() throws IOExceptionThere is, of course, a close() method.


22

try { // Construct the chainFileInputStream fis = new FileInputStream(“fname”);DataInputStream dis = new DataInputStream(fis); // R eaddouble d = dis.readDouble();int i = dis.readInt();String s = dis.readUTF(); // Close the chaindis.close(); // Close dis first, because itfis.close(); // was created last}catch (IOException e) { }


23

• The DataOutputStream class is the mirror image of the DataInputStream class. The constructor is

DataOutputStream(OutputStream ostream).• The constructor requires you to pass in an output stream.

When you write to the data output stream, it converts the parameters of the write methods to bytes and writes them to ostream.


24

The commonly used output methods of the DataOutputStream class are as follows:

void write Boolean(boolean b) throws Exceptionvoid write Byte(int b) throws Exceptionvoid write Bytes(String s) throws Exceptionvoid writeChar(int c) throws Exceptionvoid write D ouble(double d) throws Exceptionvoid writeFloat(float b) throws Exceptionvoid writeInt(int i) throws Exceptionvoid writeLong(long l) throws Exceptionvoid writeShort(int s) throws Exceptionvoid writeUTF(String s) throws Exception


25Ben Abdallah Helmi Architect J2EE

26

try {// Create the chainFileOutputStream fos = new FileOutputStream(“txt”);DataOutputStream dos = new DataOutputStream(fos);// W ritedos.write D ouble(123.456);dos.writeInt(55);dos.writeUTF(“The moving finger writes”);// Close the chaindos.close();fos.close();}catch (IOException e) { }


27

• BufferedInputStream and B ufferedOutputStream These classes have internal buffers so that bytes can be read or written in large blocks, thus minimizing I/O overhead.

• PrintStream This class can be asked to write text or primitives. Primitives are converted to character representations. The System.out and System.err objects are examples of this class. The class has a println() method that outputs a string followed by a newline character. It also has a format() method that prints formatted text. Text formatting is covered in Chapter 8, “The java.lang and java.util packages.”

• PushbackInputStream This class allows the most recently read byte to be put back into the stream, as if it had not yet been read. This functionality is very useful for certain kinds of parsers.


28

• It is possible to create stream chains of arbitrary length. For example, the following code fragment implements a data input stream that reads from a buffered input stream, which in turn reads from a file input stream:

• FileInputStream f = new FileInputStream(“text”);• BufferedInputStream b = new BufferedInputStream(f);• DataInputStream d = new DataInputStream(b);


30

Readers and Writers

• Readers and writers are like input and output streams: The low-level varieties communicate with I/O devices, and the high-level varieties communicate with low-level varieties. What makes readers and writers different is that they are exclusively oriented to Unicode characters.

The other low-level reader and writer classes are as follows:

• CharArrayReader and CharArrayWriter Read and write char arrays.

• PipedReader and PipedWriter Provide a mechanism for thread communication.

• StringReader and StringWriter Read and write strings.Ben Abdallah Helmi Architect J2EE

31

• int read() throws IOException Returns the next char (stored in the low-order 16 bits of the int return value) or -1 if at the end of input.

• int read(char dest[]) throws IOException Attempts to read enough chars to fill array dest[]. It returns the number of chars read or -1 if at the end of input.

• int read(char dest[], int offset, int len) throws IOException Attempts to read len chars into array dest[], starting at offset. It returns the number of chars read or -1 if at the end of input


32

• int read() throws IOException Returns the next char (stored in the low-order 16 bits of the int return value) or -1 if at the end of input.

• int read(char dest[]) throws IOException Attempts to read enough chars to fill array dest[]. It returns the number of chars read or -1 if at the end of input.

• int read(char dest[], int offset, int len) throws IOException Attempts to read len chars into array dest[], starting at offset. It returns the number of chars read or -1 if at the end of input

• LineNumberReader This class views its input as a sequence of lines of text. A method called readLine() returns the next line, and the class keeps track of the current line number.

• PrintWriter This class is similar to PrintStream, but it writes chars rather than bytes.

• PushbackReader This class is similar to PushbackInputStream, but it reads chars rather than bytes.Ben Abdallah Helmi Architect

J2EE

33

1. try {2. FileReader fr = new FileReader(“data”);3. LineNumberReader lnr = new LineNumberReader(fr);4. String s;5.6. while ((s = lnr.readLine()) != null) {7. System.out.println(lnr.getLineNumber() + 8. “ : “ + s);9. }10. lnr.close();11. fr.close();12. }13. catch (IOException x) { }


35

• The preceding discussion has carefully avoided a crucial point. Consider a file reader, which reads bytes from a file and returns strings of Unicode. How does the reader know how to translate an 8-bit character on the disk into a 16-bit character inside the JVM? Similarly, how does a file writer know how to translate a 16-bit Unicode character into an 8-bit byte?

• An encoding is a mapping between 8-bit characters and Unicode.


36

Object Streams and Serialization

• As you have seen, data input and output streams allow you to read and write primitives and strings, rather than individual bytes. Object streams go one step beyond data streams by allowing you to read and write entire objects.

• The process of writing an object is called serialization. To serialize an object, first create an instance of java.io.ObjectOutputStream.


37

void writeStringBuffer(StringBuffer writeMe)

throws IOException {FileOutputStream fos = new

FileOutputStrem(“sbuf.ser”);ObjectOutputStream oos = new

ObjectOutputStream(fos);oos.writeObject(writeMe);oos.close();fos.close();}

StringBuffer readStringBuffer()throws IOException,

ClassNotFoundException {FileInputStream fis = new

FileInputStream (“sbuf.ser”);ObjectInputStream ois = new

ObjectInputStream(fis);StringBuffer sb =

(StringBuffer)ois.readObject();ois.close();fis.close();return sb;}


38

• The ObjectOutputStream class has a writeUTF() method, as well as writeByte(), writeShort(), and all other write-primitive methods that also appear in data output streams.

• The ObjectInputStream class has corresponding reading methods. So if you want to create a file that contains serialized primitives and strings as well as serialized objects, you can do it with a single output stream.

• Static fields are not, because it would not be appropriate to change a static variable, which is shared by all instances of a class, just because one instance of the class got deserialized. (To deserialize is to convert a serialized representation into a replica of the original object.) Transient fields are also not serialized.

• All non-static non-transient fields are written to object output streams,regardless of whether they are public, private, default, or protected.


39

• When an object is serialized, it will probably be deserialized by a different JVM. Any JVM that tries to deserialize an object must have access to that object’s class definition. In other words, if the class is not already loaded, its class file must appear in the new JVM’s classpath. If this is not the case, readObject() will throw an exception.

• In the terminology of serialization, when an object is serialized, its entire graph is serialized. An object’s graph is the object itself, plus all the objects it references, plus all the objects those objects reference, and so on. When an object input stream deserializes an object, the entire graph is deserialized.


40

• public void writeObject(Object obj)• However, if you look at the method detail section for

writeObject(), you’ll see that it throws NotSerializableException if “some object to be serialized does not implement the java.io.Serializable interface.” So even though the method declares that its argument is an object, it contains code that checks for the precondition that the argument must be an instanceof Serializable, and it throws the exception if the precondition is not met. Even if the object being passed into the method implements Serializable, the exception might still be thrown. Since the object’s entire graph is serialized, all objects referenced by the object must implement Serializable, and all objects referenced by those objects must do the same, and so on.


41

• You probably recognize the Serializable interface from your reading of the API pages. Most of the core Java classes implement it. All the wrapper classes do so, and so do the collection classes. In fact, the only core Java classes that do not implement Serializable are like Threads

• Empty interfaces such as Serializable are known as tagging interfaces. They identify implementing classes as having certain properties, without requiring those classes to actually implement any methods.

• Arrays of primitives or serializable objects are themselves serializable. That should not be serialized


42

• Deserializing involves a lot of tricky business behind the scenes. The object input stream creates a blank instance of the object being deserialized and then sets its field values. In order for this to happen, a bizarre condition must apply. Think about the class hierarchy of the object being deserialized.

• The object itself implements Serializable; the object’s parent class might or might not implement Serializable. As you work your way up the inheritance hierarchy, you eventually get to the first superclass that is not itself serializable. That superclass must have a no-args constructor.

• Often the first non-serializable superclass is Object, which does have the right kind of constructor. If the condition isn’t met, readObject() throws java.io.InvalidClassException. The exception message says, “no valid constructor.”


43

• Notice the private access. When an object output stream executes its writeObject() method, it checks to see if the object has a writeObject() method matching the above signature. If this is the case, the stream bypasses its default behavior (which is to serialize the object’s non-static non-transient fields) and just calls the object’s writeObject() method.

• Similarly, when an object input stream executes its readObject() method, it checks to see if the object has a readObject() method matching the above signature, and if so the ordinary deserialization process is bypassed in favor of a call to the readObject() method.


44

• If a class wants its writeObject() method to take special action in addition to, rather than instead of, the default serialization behavior, it can call the output stream’s defaultWriteObject() method, which serializes the object’s non-static non-transient fields.

• As you might expect, the ObjectInputStream class has a defaultReadObject() method, which deserializes the current object from the object input stream.


45

Import java.io.*;class DoItMyself implements Serializable {private String id;protected int n;transient byte notMe;private void writeObject(ObjectOutputStream oos)throws IOException {oos.writeUTF(“The password is swordfish”);oos.defaultWriteObject();}private void readObject(ObjectInputStream ois)throws IOException, ClassNotFoundException {String password = ois.readUTF();if (!password.equals(“The password is swordfish”))throw new SecurityException(“Bad password”);ois.defaultReadObject();}}


When an instance of this class is serialized, the object output stream notices that the instancehas a writeObject() method with the appropriate signature. This method is called. A passwordstring is serialized. Then the output stream’s defaultWriteObject() is called, and default serializationis performed.

46

Another way to provide custom serialization and deserialization is to implement a subinterface of Serializable, called Externalizable. (Notice that since Externalizable extends Serializable, the implements Serializable precondition in writeObject() is met by any object that implements Externalizable.

Externalizable contains two method signatures:void writeExternal(ObjectOutput out)throws IOExceptionvoid readExternal(ObjectInput in)throws IOException, ClassNotFoundException

• ObjectOutput and ObjectInput are interfaces that are implemented by ObjectOutputStream and ObjectInputStream. They define, respectively, writeObject() and readObject() methods


47

import java.io.*;public class Account implements Externalizable {private String ownerName;private String password;private float balance;private String reverse(String reverseMe) {String reversed = "";for (int i=reverseMe.length()-1; i>=0; i--)reversed += reverseMe.charAt(i);return reversed;}public void writeExternal(ObjectOutput outStream)throws IOException {outStream.writeObject(ownerName);outStream.writeObject(reverse(password));outStream.writeObject(new Float(balance));}public void readExternal(ObjectInput inStream)throws IOException, ClassNotFoundException {ownerName = (String)inStream.readObject();String reversedPassword =(String)inStream.readObject();password = reverse(reversedPassword);balance = ((Float)inStream.readObject()).floatValue();}}


When an instance of this class is passed to an object output stream, the default serializationprocedure is bypassed; instead, the stream calls the instance’s writeExternal() method. When an object input stream reads a serialized instance of Account, a call is made to the no-args constructor for the Account class; this constructor must be public. Then the newly constructed object receives a readExternal() call so that it can reconstitute its serialized values.

48

• Notice that the readObject() mechanism of ObjectInputStream relies on the existence of a no-args constructor for any class that implements Externalizable. If an externalizable class has no no-args constructor, the readObject() method will throw java.io.InvalidClassException.


chap 9 : i/o and streams (scjp/ocjp)

Education

file file

file instance

length file

file object

file constructor

file f2

file f1

file access