home | O'Reilly's CD bookshelfs | FreeBSD | Linux | Cisco | Cisco Exam    

Java Fundamental Classes Reference

Previous Chapter 6 Next
 

6. I/O

Contents:
Input Streams and Readers
Output Streams and Writers
File Manipulation

The java.io package contains the fundamental classes for performing input and output operations in Java. These I/O classes can be divided into four basic groups:

  • Classes for reading input from a stream.

  • Classes for writing output to a stream.

  • Classes for manipulating files.

  • Classes for serializing objects.

All fundamental I/O in Java is based on streams. A stream represents a flow of data, or a channel of communication. Conceptually, there is a reading process at one end of the stream and a writing process at the other end. Java 1.0 supported only byte streams, which meant that Unicode characters were not always handled correctly. As of Java 1.1, there are classes in java.io for both byte streams and character streams. The character stream classes, which are called readers and writers, handle Unicode characters appropriately.

The rest of this chapter describes the classes in java.io that read from and write to streams, as well as the classes that manipulate files. The classes for serializing objects are described in Chapter 7, Object Serialization.

6.1 Input Streams and Readers

The InputStream class is an abstract class that defines methods to read sequentially from a stream of bytes. Java provides subclasses of the InputStream class for reading from files, StringBuffer objects, and byte arrays, among other things. Other subclasses of InputStream can be chained together to provide additional logic, such as keeping track of the current line number or combining multiple input sources into one logical input stream. It is also easy to define a subclass of InputStream that reads from any other kind of data source.

In Java 1.1, the Reader class is an abstract class that defines methods to read sequentially from a stream of characters. Many of the byte-oriented InputStream subclasses have character-based Reader counterparts. Thus, there are subclasses of Reader for reading from files, character arrays, and String objects.

InputStream

The InputStream class is the abstract superclass of all other byte input stream classes. It defines three read() methods for reading from a raw stream of bytes:

read()
read(byte[] b)
read(byte[] b, int off, int len)

If there is no data available to read, these methods block until input is available. The class also defines an available() method that returns the number of bytes that can be read without blocking and a skip() method that skips ahead a specified number of bytes. The InputStream class defines a mechanism for marking a position in the stream and returning to it later, via the mark() and reset() methods. The markSupported() method returns true in subclasses that support these methods.

Because the InputStream class is abstract, you cannot create a "pure" InputStream. However, the various subclasses of InputStream can be used interchangeably. For example, methods often take an InputStream as a parameter. Such a method accepts any subclass of InputStream as an argument.

InputStream is designed so that read(byte[]) and read(byte[], int, int) both call read(). Thus, when you subclass InputStream, you only need to define the read() method. However, for efficiency's sake, you should also override read(byte[], int, int) with a method that can read a block of data more efficiently than reading each byte separately.

Reader

The Reader class is the abstract superclass of all other character input stream classes. It defines nearly the same methods as InputStream, except that the read() methods deal with characters instead of bytes:

read()
read(char[] cbuf)
read(char[] cbuf, int off, int len)

The available() method of InputStream has been replaced by the ready() method of Reader, which simply returns a flag that indicates whether or not the stream must block to read the next character.

Reader is designed so that read() and read(char[]) both call read(char[], int, int). Thus, when you subclass Reader, you only need to define the read(char[], int, int) method. Note that this design is different from, and more efficient than, that of InputStream.

InputStreamReader

The InputStreamReader class serves as a bridge between InputStream objects and Reader objects. Although an InputStreamReader acts like a character stream, it gets its input from an underlying byte stream and uses a character encoding scheme to translate bytes into characters. When you create an InputStreamReader, specify the underlying InputStream and, optionally, the name of an encoding scheme. For example, the following code fragment creates an InputStreamReader that reads characters from a file that is encoded using the ISO 8859-5 encoding:

String fileName = "encodedfile.txt"; String encodingName = "8859_5";
InputStreamReader in;
try {
   x FileInputStream fileIn = new FileInputStream(fileName);
    in = new InputStreamReader(fileIn, encodingName);
} catch (UnsupportedEncodingException e1) {
    System.out.println(encodingName + " is not a supported encoding scheme.");
} catch (IOException e2) {
    System.out.println("The file " + fileName + " could not be opened.");
}

FileInputStream and FileReader

The FileInputStream class is a subclass of InputStream that allows a stream of bytes to be read from a file. The FileInputStream class has no explicit open method. Instead, the file is implicitly opened, if appropriate, when the FileInputStream is created. There are three ways to create a FileInputStream:

  • You can create a FileInputStream by passing the name of a file to be read:

    FileInputStream f1 = new FileInputStream("foo.txt");
    

  • You can create a FileInputStream with a File object:

    File f = new File("foo.txt");
    FileInputStream f2 = new FileInputStream(f);
    

  • You can create a FileInputStream with a FileDescriptor object. A FileDescriptor object encapsulates the native operating system's representation of an open file. You can get a FileDescriptor from a RandomAccessFile by calling its getFD() method. You create a FileInputStream that reads from the open file associated with a RandomAccessFile as follows:

    RandomAccessFile raf;
    raf = new RandomAccessFile("z.txt","r");
    FileInputStream f3 = new FileInputStream(raf.getFD());
    

    The FileReader class is a subclass of Reader that reads a stream of characters from a file. The bytes in the file are converted to characters using the default character encoding scheme. If you do not want to use the default encoding scheme, you need to wrap an InputStreamReader around a FileInputStream, as shown above. You can create a FileReader from a filename, a File object, or a FileDescriptor object, as described above for FileInputStream.

StringReader and StringBufferInputStream

The StringReader class is a subclass of Reader that gets its input from a String object. The StringReader class supports mark-and-reset functionality via the mark() and reset() methods. The following example shows the use of StringReader:

StringReader sr = new StringReader("abcdefg");
try {
    char[] buffer = new char[3];
    sr.read(buffer);
    System.out.println(buffer);
} catch (IOException e) {
    System.out.println("There was an error while reading.");
}

This code fragment produces the following output:

abc

The StringBufferInputStream class is the byte-based relative of StringReader. The entire class is deprecated as of Java 1.1 because it does not properly convert the characters of the string to a byte stream; it simply chops off the high eight bits of each character. Although the markSupported() method of StringBufferInputStream returns false, the reset() method causes the next read operation to read from the beginning of the String.

CharArrayReader and ByteArrayInputStream

The CharArrayReader class is a subclass of Reader that reads a stream of characters from an array of characters. The CharArrayReader class supports mark-and-reset functionality via the mark() and reset() methods. You can create a CharArrayReader by passing a reference to a char array to a constructor like this:

char[] c;
...
CharArrayReader r;
r = new CharArrayReader(c);

You can also create a CharArrayReader that only reads from part of an array of characters by passing an offset and a length to the constructor. For example, to create a CharArrayReader that reads elements 5 through 24 of a char array you would write:

r = new CharArrayReader(c, 5, 20);

The ByteArrayInputStream class is just like CharArrayReader, except that it deals with bytes instead of characters. In Java 1.0, ByteArrayInputStream did not fully support mark() and reset(); in Java 1.1 these methods are completely supported.

PipedInputStream and PipedReader

The PipedInputStream class is a subclass of InputStream that facilitates communication between threads. Because it reads bytes written by a connected PipedOutputStream, a PipedInputStream must be connected to a PipedOutputStream to be useful. There are a few ways to connect a PipedInputStream to a PipedOutputStream. You can first create the PipedOutputStream and pass it to the PipedInputStream constructor like this:

PipedOutputStream po = new PipedOutputStream();
PipedInputStream pi = new PipedInputStream(po);

You can also create the PipedInputStream first and pass it to the PipedOutputStream constructor like this:

PipedInputStream pi = new PipedInputStream();
PipedOutputStream po = new PipedOutputStream(pi);

The PipedInputStream and PipedOutputStream classes each have a connect() method you can use to explicitly connect a PipedInputStream and a PipedOutputStream as follows:

PipedInputStream pi = new PipedInputStream();
PipedOutputStream po = new PipedOutputStream();
pi.connect(po);

Or you can use connect() as follows:

PipedInputStream pi = new PipedInputStream();
PipedOutputStream po = new PipedOutputStream();
po.connect(pi);

Multiple PipedOutputStream objects can be connected to a single PipedInputStream at one time, but the results are unpredictable. If you connect a PipedOutputStream to an already connected PipedInputStream, any unread bytes from the previously connected PipedOutputStream are lost. Once the two PipedOutputStream objects are connected, the PipedInputStream reads bytes written by either PipedOutputStream in the order that it receives them. The scheduling of different threads may vary from one execution of the program to the next, so the order in which the PipedInputStream receives bytes from multiple PipedOutputStream objects can be inconsistent.

The PipedReader class is the character-based equivalent of PipedInputStream. It works in the same way, except that a PipedReader is connected to a PipedWriter to complete the pipe, using either the appropriate constructor or the connect() method.

FilterInputStream and FilterReader

The FilterInputStream class is a wrapper class for InputStream objects. Conceptually, an object that belongs to a subclass of FilterInputStream is wrapped around another InputStream object. The constructor for this class requires an InputStream. The constructor sets the object's in instance variable to reference the specified InputStream, so from that point on, the FilterInputStream is associated with the given InputStream. All of the methods in FilterInputStream work by calling the corresponding methods in the underlying InputStream. Because the close() method of a FilterInputStream calls the close() method of the InputStream that it wraps, you do not need to explicitly close the underlying InputStream.

A FilterInputStream does not add any functionality to the object that it wraps, so by itself it is not very useful. However, subclasses of the FilterInputStream class do add functionality to the objects that they wrap in two ways:

  • Some subclasses add logic to the InputStream methods. For example, the InflaterInputStream class in the java.util.zip package decompresses data automatically in the read() methods.

  • Some subclasses add new methods. An example is DataInputStream, which provides methods for reading primitive Java data types from the stream.

The FilterReader class is the character-based equivalent of FilterInputStream. A FilterReader is wrapped around an underlying Reader object; the methods of FilterReader call the corresponding methods of the underlying Reader. However, unlike FilterInputStream, FilterReader is an abstract class, so you cannot instantiate it directly.

DataInputStream

The DataInputStream class is a subclass of FilterInputStream that provides methods for reading a variety of data types. The DataInputStream class implements the DataInput interface, so it defines methods for reading all of the primitive Java data types.

You create a DataInputStream by passing a reference to an underlying InputStream to the constructor. Here is an example that creates a DataInputStream and uses it to read an int that represents the length of an array and then to read the array of long values:

long[] readLongArray(InputStream in) throws IOException {
    DataInputStream din = new DataInputStream(in);
    int count = din.readInt();
    long[] a = new long[count];
    for (int i = 0; i < count; i++) {
        a[i] = din.readLong();
    }
    return a;
}

BufferedReader and BufferedInputStream

The BufferedReader class is a subclass of Reader that buffers input from an underlying Reader. A BufferedReader object reads enough characters from its underlying Reader to fill a relatively large buffer, and then it satisfies read operations by supplying characters that are already in the buffer. If most read operations read just a few characters, using a BufferedReader can improve performance because it reduces the number of read operations that the program asks the operating system to perform. There is generally a measurable overhead associated with each call to the operating system, so reducing the number of calls into the operating system improves performance. The BufferedReader class supports mark-and-reset functionality via the mark() and reset() methods.

Here is an example that shows how to create a BufferedReader to improve the efficiency of reading from a file:

try {
    FileReader fileIn = new FileReader("data.dat");
    BufferedReader in = new BufferedReader(fileIn);
    // read from the file
} catch (IOException e) {
    System.out.println(e);
}

The BufferedInputStream class is the byte-based counterpart of BufferedReader. It works in the same way as BufferedReader, except that it buffers input from an underlying InputStream.

LineNumberReader and LineNumberInputStream

The LineNumberReader class is a subclass of BufferedReader. Its read() methods contain additional logic to count end-of-line characters and thereby maintain a line number. Since different platforms use different characters to represent the end of a line, LineNumberReader takes a flexible approach and recognizes "\n", "\r", or "\r\n" as the end of a line. Regardless of the end-of-line character it reads, LineNumberReader returns only "\n" from its read() methods.

You can create a LineNumberReader by passing its constructor a Reader. The following example prints out the first five lines of a file, with each line prefixed by its number. If you try this example, you'll see that the line numbers begin at 0 by default:

try {
    FileReader fileIn = new FileReader("text.txt");
    LineNumberReader in = new LineNumberReader(fileIn);
    for (int i = 0; i < 5; i++)
        System.out.println(in.getLineNumber() + " " + in.readLine());
}catch (IOException e) {
    System.out.println(e);
}

The LineNumberReader class has two methods pertaining to line numbers. The getLineNumber() method returns the current line number. If you want to change the current line number of a LineNumberReader, use setLineNumber(). This method does not affect the stream position; it merely sets the value of the line number.

The LineNumberInputStream is the byte-based equivalent of LineNumberReader. The entire class is deprecated in Java 1.1 because it does not convert bytes to characters properly. Apart from the conversion problem, LineNumberInputStream works the same as LineNumberReader, except that it takes its input from an InputStream instead of a Reader.

SequenceInputStream

The SequenceInputStream class is used to sequence together multiple InputStream objects. Consider this example:

FileInputStream f1 = new FileInputStream("data1.dat");
FileInputStream f2 = new FileInputStream("data2.dat");
SequenceInputStream s = new SequenceInputStream(f1, f2);

This example creates a SequenceInputStream that reads all of the bytes from f1 and then reads all of the bytes from f2 before reporting that it has encountered the end of the stream. You can also cascade SequenceInputStream object themselves, to allow more than two input streams to be read as if they were one. You would write it like this:

FileInputStream f3 = new FileInputStream("data3.dat");
SequenceInputStream s2 = new SequenceInputStream(s, f3);

The SequenceInputStream class has one other constructor that may be more appropriate for wrapping more than two InputStream objects together. It takes an Enumeration of InputStream objects as its argument. The following example shows how to create a SequenceInputStream in this manner:

Vector v = new Vector();
v.add(new FileInputStream("data1.dat"));
v.add(new FileInputStream("data2.dat"));
v.add(new FileInputStream("data3.dat"));
Enumeration e = v.elements();
SequenceInputStream s = new SequenceInputStream(e);

PushbackInputStream and PushbackReader

The PushbackInputStream class is a FilterInputStream that allows data to be pushed back into the input stream and reread by the next read operation. This functionality is useful for implementing things like parsers that need to read data and then return it to the input stream. The Java 1.0 version of PushbackInputStream supported only a one-byte pushback buffer; in Java 1.1 this class has been enhanced to support a larger pushback buffer.

To create a PushbackInputStream, pass an InputStream to its constructor like this:

FileInputStream ef = new FileInputStream("expr.txt");
PushbackInputStream pb = new PushbackInputStream(ef);

This constructor creates a PushbackInputStream that uses a default one-byte pushback buffer. When you have data that you want to push back into the input stream to be read by the next read operation, you pass the data to one of the unread() methods.

The PushbackReader class is the character-based equivalent of PushbackInputStream. In the following example, we create a PushbackReader with a pushback buffer of 48 characters:

FileReader fileIn = new FileReader("expr.txt");
PushbackReader in = new PushbackReader(fileIn, 48);

Here is an example that shows the use of a PushbackReader:

public String readDigits(PushbackReader pb) {
    char c;
    StringBuffer buffer = new StringBuffer();
    try {
        while (true) {
            c = (char)pb.read();
            if (!Character.isDigit(c))
                break;
            buffer.append(c);
        }
        if (c != -1)
            pb.unread(c);
    }catch (IOException e) {}
    return buffer.toString();
}

The above example shows a method that reads characters corresponding to digits from a PushbackReader. When it reads a character that is not a digit, it calls the unread() method so that the nondigit can be read by the next read operation. It then returns a string that contains the digits that were read.


Previous Home Next
Hashtables Book Index Output Streams and Writers

Java in a Nutshell Java Language Reference Java AWT Java Fundamental Classes Exploring Java






??????????????@Mail.ru