The JavaTM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Trail: Essential Java Classes
Lesson: I/O: Reading and Writing (but no 'rithmetic)

## Overview of I/O Streams

> To bring in information, a program opens a stream on an information source (a file, memory, a socket) and reads the information sequentially, as shown here:

> Similarly, a program can send information to an external destination by opening a stream to a destination and writing the information out sequentially, like this:

> No matter where the data is coming from or going to and no matter what its type, the algorithms for sequentially reading and writing data are basically the same:

> > Reading | Writing
> >     open a stream
> >     while more information
> >         read information
> >     close the stream
> >     open a stream
> >     while more information
> >         write information
> >     close the stream

> The `java.io` package contains a collection of stream classes that support these algorithms for reading and writing. To use these classes, a program needs to import the `java.io` package. The stream classes are divided into two class hierarchies, based on the data type (either characters or bytes) on which they operate.

### Character Streams

> `Reader` and `Writer` are the abstract superclasses for character streams in `java.io`. `Reader` provides the API and partial implementation for readers--streams that read 16-bit characters--and `Writer` provides the API and partial implementation for writers--streams that write 16-bit characters. Subclasses of `Reader` and `Writer` implement specialized streams and are divided into two categories: those that read from or write to data sinks (shown in gray in the following figures) and those that perform some sort of processing (shown in white). The figure shows the class hierarchies for the `Reader` and `Writer` classes.

> Most programs should use readers and writers to read and write textual information. The reason is that they can handle any character in the Unicode character set, whereas the byte streams are limited to ISO-Latin-1 8-bit bytes.

### Byte Streams

> To read and write 8-bit bytes, programs should use the byte streams, descendants of `InputStream` and `OutputStream`. `InputStream` and `OutputStream` provide the API and partial implementation for input streams (streams that read 8-bit bytes) and output streams (streams that write 8-bit bytes). These streams are typically used to read and write binary data such as images and sounds. Two of the byte stream classes, `ObjectInputStream` and `ObjectOutputStream`, are used for object serialization. These classes are covered in Object Serialization.

> As with `Reader` and `Writer`, subclasses of `InputStream` and `OutputStream` provide specialized I/O that falls into two categories, as shown in the following class hierarchy figure: data sink streams (shaded) and processing streams (unshaded).

### Understanding the I/O Superclasses

> `Reader` and `InputStream` define similar APIs but for different data types. For example, `Reader` contains these methods for reading characters and arrays of characters:

> >     int read()
> >     int read(char cbuf[])
> >     int read(char cbuf[], int offset, int length)

> `InputStream` defines the same methods but for reading bytes and arrays of bytes:

> >     int read()
> >     int read(byte cbuf[])
> >     int read(byte cbuf[], int offset, int length)

> Also, both `Reader` and `InputStream` provide methods for marking a location in the stream, skipping input, and resetting the current position.

> `Writer` and `OutputStream` are similarly parallel. `Writer` defines these methods for writing characters and arrays of characters:

> >     int write(int c)
> >     int write(char cbuf[])
> >     int write(char cbuf[], int offset, int length)

> And `OutputStream` defines the same methods but for bytes:

> >     int write(int c)
> >     int write(byte cbuf[])
> >     int write(byte cbuf[], int offset, int length)

> All of the streams--readers, writers, input streams, and output streams--are automatically opened when created. You can close any stream explicitly by calling its `close` method. Or the garbage collector can implicitly close it, which occurs when the object is no longer referenced.

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Copyright 1995-2001 Sun Microsystems, Inc. All rights reserved.