More on I/O Streams

IO

Different versions of the Core Java texts have the "Streams and Files" chapter in different volumes. (Newer editions have it in Volume 1.) They, too, note that I/O is "not particularly exciting, but without the ability to read and write data, your programs are severely limited."
In general, don't forget that the text is a valuable source of information and examples.

OutputStream

write()

flush(): "because you do not know what an output stream is connected to, you might be required to "flush" your output through buffered cache to get it to be written (in a timely matter, or at all). OutputStream's version of this method does nothing..."

BufferedOutputStream and PrintStream override this method... later

close(): "just like for an InputStream you should explicitly close an OutputStream so that it can release any resources it may have reserved in your behalf."

Opening a FileOutputStream

Same as for FileInput

FileOutputStream myFileStream; myFileStream = new FileOutputStream ("/dir/filename"); or File myfile; FileOutputStream myFileStream; myFile = new File ("/dir/filename"); myFileStream = new FileOutputStream (myFile); Writing to a FileOutputStream void write() // writes one byte void write(byte b[]) // fills entire arrray void write(byte b[], int offset, int len) // writes len bytes into b starting at b[offset]

Code:

import java.io.*; /** * Phones.java * A simple database creation program * Demonstrates basic keyboard input * Demonstrates basic file output */ class Phones { static FileOutputStream fos; public static final int lineLength = 81; public static void main(String args[]) throws IOException { byte[] phone = new byte[lineLength]; byte[] name = new byte[lineLength]; int i; fos = new FileOutputStream("phone.numbers"); while (true) { System.out.println("Enter a name (enter 'done' to quit)"); readLine(name); // defined below if ("done".equalsIgnoreCase(new String(name,0,0,4))) { break; } System.out.println("Enter the phone number"); readLine(phone); for (i=0; phone[i] != 0; i++) { fos.write(phone[i]); } fos.write(','); for (i=0; name[i] != 0; i++) { fos.write(name[i]); } fos.write('\n'); } fos.close(); } private static void readLine(byte line[]) throws IOException { int i=0,b=0; while ((i < (lineLength - 1)) && ((b = System.in.read()) != '\n')) { line[i++] = (byte)b; } line[i]=(byte)0; } }

FilterOutputStream

This 'abstract' class simply provides a 'pass-through' for all of the standard methods of OutputStream. It holds inside itself another stream, by definition one further 'down' the chain of filters, to which it forwards all method calls. It implements nothing new but allows itself to be nested:

OutputStream s = new FileOutputStream("foo");

FilterOutputStream s1 = new FilterOutputStream(s);

FilterOutputStream s2 = new FilterOutputStream(s1);

FilterOutputStream s3 = new FilterOutputStream(s2);

...s3.write(123) ...

Whenever a write is performed on the filtered stream s3, it passes along the request to s2. Then s2 does the same to s1, and finally s is asked to output the bytes. Subclasses of FilterOutputStream of course, do some nontrivial processing of the bytes as they flow past. This chain can be tightly nested"

s3 = new FilterOutputStream(new FilterOutputStream(new FilterOutputStream(s)));

BufferedOutputStream

(For characters, see BufferedWriter. Also, for primitive data types, remember Scanner ( API)

Output efficiency is increased by storing values to be written in a buffer and actually writing them only when the buffer fills up or when flush() is called.

FromJava in 21 days, page 395:

"BufferedOutputStream is one of the most valuable of all streams. All it does is implement the full complement of OutputStream's methods, but it does so by using a buffered array of bytes that act as a cache for writing. This decouples the rate and the size of the "chunks" you're writing from the more regular large block sizes in which streams are most efficiently written (to peripheral devices, files in the file system, or the network, for example).

BufferedOutputStream is one of two classes in the Java library to implement flush(), which pushes the bytes you've written through the buffer and out the other side. Because buffering is soo valuable, you might wish that every output stream could somehow be buffered. Fortunately, you can surround any output stream in such a way to achieve just that:"

BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("foo")); or FileOutputStream fos = new FileOutputStream("foo")); BufferedOutputStream bos = new BufferedOutputStream(fos);

RandomAccessFile

Often you may not want to read a file from beginning to end. You may want to access a text file as a database, where you jump around reading one record, then another, then another, etc. - each in different parts of the file.

Here is a brief example that appends a string to an existing file:

import java.io.IOException; import java.io.RandomAccessFile; class raTest { public static void main(String args[]) throws IOException { RandomAccessFile myRAFile; //open random access file myRAFile = new RandomAccessFile("/tmp/java.log","rw"); String s = "Information to Append\nHi mom!\n"; //move to the end of the file myRAFile.seek(myRAFile.length()); // start appending myRAFile.writeBytes(s); myRAFile.close(); } }