COMP 212 Lab 09: Stream-based I/O

This tutorial is all about how to do non-GUI I/O in Java. It is essentially an out-of-class lecture.

In Java, input and output is defined in terms of an abstract concept called "stream". A stream is a sequence of data; conceptually it is like a list, but not necessarily with an end.

We use distinct types of streams for input and output.

• An input stream has source, such as the keyboard or a file.
• An output stream has a destination, such as the screen or a file.

• Byte streams contain bytes, which are usually considered some computer-friendly internal representation of Java data.
• Character streams contain characters, and are thus a human-friendly string-based representation of data.

The InputStream and OutputStream classes

Input and output in Java of byte streams are handled through subclasses of the java.io.InputStream and java.io.OutputStream classes. These classes are abstractions that Java provides for dealing with reading and writing information sequentially to and from anything you want: e.g., a disk, a string buffer, an enumeration, or an array of bytes.

Input streams

Below is the UML diagram for a few commonly used concrete subclasses of InputStream. Note that the StreamTokenizer class shown in the diagram is not a subclass of InputStream. StreamTokenizer is a utility class used to parse the stream of input, and will be discussed below.

The first step in using a concrete input stream class is to specify its source for its constructor. For instance, to read the contents of a file into a String, you create a new FileInputStream, giving the filename in the constructor, as in the following:

     import java.io.*; 

     ...
 
     String buffer = new String(); 

     // read bytes until eof 
     try 
     { 
        // FileInputStream constructor takes
        // a String, a File object, or a FileDescriptor object .
        FileInputStream infile = new FileInputStream("myfile.txt");

        for (int i = infile.read(); i != -1; i = infile.read()) { 
           buffer += (char) i;
        }

        infile.close(); 
     } 
     catch(IOException e) { 
        System.err.println("Could not read from myfile.txt"); 
     } 
     catch(FileNotFoundException e) { 
        System.err.println("myfile.txt not found"); 
     } 

The available() method returns the number of bytes that can be read from the stream. The close() method closes the link between the program and the source of the data. After you close the stream, you cannot read from it anymore until you open it up again. The reset() method ensures that the next input operation on this stream begins at the top of the file again. Several read() methods are available. Each datum is read as an int or byte; to convert it to a char, you have to cast it.

Output streams

Output streams are very similar. Below is the UML diagram for a few commonly used concrete subclasses of OutputStream.

Input and output for characters streams are handled through subclasses of the java.io.Reader and java.io.Writer classes. These classes are abstractions that Java provides for dealing with reading and writing character data.

Below are the UML diagrams for a few commonly used Reader and Writer classes:

Exercise: TestStreamTokenizer.java is a sample program showing how to use it. Copy it and the file ~comp212/public_html/01-spring/labs/09/input.txt to your local directory and test it. This is similar to one piece of the RPN calculator project.

I/O and the System class

The java.lang.System class is a useful class containing useful static members, such as

     System.out.println("Hello world!");

     % java MyClass

     % java MyClass > outputfile

There is also a System.in class, similarly initialized to the InputStream standard input or stdin. Stdin represents the keyboard, but we can similarly change System.in by redirecting the input:

     % java MyClass < inputfile

There is also a System.errPrintStream standard error or stderr. Stderr also represents the monitor screen, so what's the point? This is intended to be the output stream used for error messages, and you can redirect it independently of stdout.

     % java MyClass > outputfile
     % java MyClass >& output_and_errorfile

     % java MyClass 1> outputfile 2> errorfile

NOTE: System.out and System.err are the only PrintStream objects you should use. The PrintStream is deprecated, i.e., a historical hold-over that my go away. For output character streams, you should use PrintWriter instead (as described above).

So how would you read in an arbitrary number of floating point numbers from the keyboard? Here's a sample.

Command-line arguments

With many programs, you want to be able to set options about how your program should behave at runtime. For instance, your Java compiler needs to know what files to compile, or you might have a variety of features that you want your users to have access to. (Check out the manual page for the Unix command ls. There's a vast amount of features regarding how to display your data, what to display, etc.) You can handle this in several ways, but a common technique is to use command-line arguments.

Remember how all your main functions for your programs have to have the same signature?

     public static void main(String[] argv) {...}

Exercise: The program Echo.java just echos back the command-line arguments to stdout. Look at it, run it, and make sure you know how to give it some command-line arguments.