Lesson 13.3 Wrappers

Stream Wrappers & Buffering

As you saw in the last section, Java's FileInputStream can actually read all of the bytes in a file at once, by using byte arrays. Unfortunately, using byte arrays means you can't do the byte-by-byte processing that is required for applications such as filters. Instead, you have to read everything into memory, process it, and then write it back out. That can get really complicated.

Buffering makes your programs much more efficient because it cuts back on the transportation overhead of moving your data from source to sink. But it doesn't require you to give up byte-by-byte processing like using byte arrays does.

Back to Top

Buffered Streams

If you want to read from a file, you first construct a FileInputStream like this: 

FileInputStream fis = null; try {    fis = new FileInputStream("Temp.txt");   ... }

This connects your input stream to a particular source. 

To add buffering, you just pass your fully constructed FileInputStream as an argument to the BufferedInputStream constructor, like this: 

FileInputStream fis = null; BufferedInputStream bis = null; try {    fis = new FileInputStream("Temp.txt");    bis = new BufferedInputStream(fis); }

Now, your FileInputStream is "wrapped up" inside the BufferedInputStream. You get the best of both worlds:

Back to Top

Buffered vs UnBuffered

Here's the listing for Buffered.java. It simply opens and reads the file whose name is passed as args[0]. (If you run these programs on the Mac, remember to supply the arguments required to JBindery. If you don't supply a file name, the program doesn't do anything..

Before reading information, the current time is retrieved using the method:

As the file is read, the number of bytes in the file is counted. After reading the file, the currentTimeMillis() method is called again, and the elapsed time calculated and printed.

The Unbuffered application is identical except for a name change and the elimination of the BufferedInputStream bis:

Buffered.java

import java.io.*; public class Buffered {   public static void main(String[] args)   {     if (args.length < 1)     {       System.err.println("java Buffered <file>");       System.exit(1);     }     FileInputStream fis = null;     BufferedInputStream bis = null;     long time = 0;     int ch, n = 0;     try     {       fis = new FileInputStream(args[0]);       bis = new BufferedInputStream(fis);       time = System.currentTimeMillis();       while ((ch = bis.read()) != -1)             n++;     }     catch (Exception e)     {       System.err.println("OOPS!!!");     }     finally     {       try       {         if (fis != null) fis.close();         if (bis != null) bis.close();       }       catch (IOException ie) { }     }     System.out.println("Buffered " + n +          "bytes in " +         (System.currentTimeMillis() - time) +         " milliseconds");   } }

Back to Top

The Results

• Buffered I/O is faster than unbuffered, everything else being equal.
• Everything else is seldom equal.

Binary Files

• To store this in human readable form [even assuming 1-byte characters], requires 12 bytes. 
• When you want to read the number from disk, you have to read it as a String, and then convert the String to a format suitable for processing such as a float or double.
• When it comes time to write it back to disk, you have to convert it from a float back into the textual form stored on disk.

Back to Top

Binary Files and Java

The Java solution is to create a cross-platform storage format and to provide two stream classes, DataInputStream and DataOutputStream, that will read and write these types of files no matter what platform you're reading or writing from.

Using Data Streams

You open a DataInputStream or a DataOutputStream the same way you do a BufferedInputStream, by wrapping.

If you want to create a file named "nums.dat" that holds binary information, you use DataOutputStream, along with a suitable FileOutputStream, like this: 

Writing Data

For instance, to write a double to the DataOutputStream dout, you write:

Here's a short application, RandomDoubles.java, that writes 1000 doubles to the disk file named "nums.dat".

RandomDoubles.java

import java.io.*; public class RandomDoubles {   public static void main(String[] args)   {     FileOutputStream fout = null;     DataOutputStream dout = null;     try     {       fout = new FileOutputStream("nums.dat");       dout = new DataOutputStream(fout);       for (int i = 0; i < 1000; i++)        dout.writeDouble(Math.random());       dout.close();       fout.close();     }     catch (Exception e)     {       System.err.println("OOPS!");     }   } }

Back to Top

The Results

When you run this program, 1,000 doubles are written to disk as binary numbers. The disk file thus takes up exactly 8,000 bytes as you can see here:

If you open the file in DOS Edit, you'll see that the numbers are definitely not "human readable."

Reading Data

To get your information out, you simply replace the DataOutputStream dout with a DataInputStream, dis, replace the FileOutputStream with a  FileInputStream, and replace

with

There is one additional complication, however. How do you tell when you've read all of your data.

Here's the relevant piece of code from ReadRandom.java which reads and displays the file "nums.dat" created by the RandomDoubles application.

try {   fis = new FileInputStream("nums.dat");   dis = new DataInputStream(fis);   while (true)   {     System.out.println(dis.readDouble());   } } catch (EOFException eoe) {   System.out.println("Terminated normally"); }

The program reads each of the random numbers written to "nums.dat" by Math.random() and prints them to the screen. When the last number is read, the EOFException is thrown and the program prints its "normal termination" message as you can see here:

Back to Top

Something to Talk About

• Download and compile the Buffered and Unbuffered applications.
• Pick a large file around 200KB and run the two programs against the same file. 

Please continue to the next section of this lesson.

Back to Top