CS 535: Object-Oriented Programming & Design

1. References
2. The I/O Package
   1. Reader
   2. Writer
   3. PrintWriter
   4. PrintStream
   5. Easy Input - UnicodeReader
   6. Creating New Streams
   7. Converting between Char and Byte based Streams
   8. Compressed Streams
   9. Stream Streams
      1. OutputStream
      2. FileInputStream
      3. FileOutputStream
      4. ASCIIInputStream
      5. Combining InputStreams
      6. Combining OutputStreams

Peter Williams

Doc 17, Java IO Slide # 1

A source (input streams) or

A destination (output stream)

InputStream

OutputStream

Doc 17, Java IO Slide # 2

Streams uses to read/write raw bytes

Initially used to read/write text

Do not handle Unicode well

java.io classes ending in Stream

Use for all text IO

Handles Unicode and local encodings properly

More efficient than byte based streams

java.io classes ending in Reader or Writer

Used for input - reading

Byte based input stream classes end in InputStream

Character based input stream classes end in Reader

Used for output - writing

Byte based input stream classes end in OutputStream

Character based input stream classes end in Writer

Doc 17, Java IO Slide # 3

BufferedReader   BufferedInputStream
FileReader   FileInputStream

BufferedWriter   BufferedOutputStream
FileWriter   FileOutputStream

Doc 17, Java IO Slide # 4

Byte based input

Byte based output

Character based input (Reader)

Character based output (Writer)

Useful in communications between threads

Read/write byte arrays

Abstract classes, filter bytes from another stream

Can be chained together

Adds buffering

Reads/writes built-in types (int, float, etc. )

Steam stores types in binary not ASCII or Unicode

Used for file IO

Doc 17, Java IO Slide # 5

Doc 17, Java IO Slide # 6

Close the stream.

Mark the present position in the stream.

Tell whether this stream supports the mark() operation.

Read a single character.

Read characters into an array.

Read characters into a portion of an array.

Tell whether this stream is ready to be read.

Repositions the stream to the last marked position.

Skip n characters.

Doc 17, Java IO Slide # 7

class  CountSize  
   {
   public static void main( String args[] ) throws IOException, 
                              FileNotFoundException
      {
      try
         {
         Reader in = new FileReader( "Exam" );
         
         int total;
         
         for ( total = 0; in.read() != -1; total++)
            ;
         System.out.println( total );
         }
      catch ( FileNotFoundException fileProblem )
         {
         System.err.println( "File not found" );
         throw fileProblem;
         }
      catch ( IOException ioProblem )
         {
         System.err.println( "IO problem" );
         throw ioProblem;
         }
      }
   }

Doc 17, Java IO Slide # 8

read() returns -1 if end of stream is reached, else returns the next byte

class  Read  
   {
   public static void main( String args[] ) throws IOException
      {
      Reader in = new StringReader( "abcdefghij" );
      
      System.out.println( in.read() + " raw read, ascii value " );
      System.out.println( (char) in.read() + " cast read to char " );
      
      }
   }

Doc 17, Java IO Slide # 9

Closes the stream

Flushes the stream

Writes an array of chars

Writes a sub array of chars

Writes a single character

Write a string

Doc 17, Java IO Slide # 10

class  Capitalize  
   {
   public static void main( String args[] ) throws IOException
      {
      Reader in  = new StringReader( "abcdefghij" );

      Writer out = new FileWriter( "Example");
      
      int nextChar;
      
      while ( ( nextChar = in.read() ) != -1  )
         out.write(  Character.toUpperCase( (char) nextChar ) );

      out.write( '\n' );
      out.flush();      // not needed before a close
      out.close();      // exiting program closes the Writer
      }
   }

Doc 17, Java IO Slide # 11

Creates a new PrintWriter.

Creates a new PrintWriter, with auto flushing.

Flushes the print writer and returns whether or not there was an error on the writer.

Doc 17, Java IO Slide # 12

class EasyPrint
   {
   public static void main( String args[] ) throws IOException
      {
      Writer out = new FileWriter( "LetterHome");
      PrintWriter easyOut = new PrintWriter( out );

      easyOut.println( "Hi Mom" );
      easyOut.println( 5 );
      easyOut.println( true );
      easyOut.close();
      }
   }

Doc 17, Java IO Slide # 13

      Writer out = new FileWriter( "LetterHome");

      PrintWriter easyOut = new PrintWriter( out );

Doc 17, Java IO Slide # 14

class BufferExample
   {
   public static void main( String args[] ) throws IOException
      {
      Writer out = new FileWriter( "LetterHome");
      BufferedWriter buffered = new BufferedWriter( out);
      PrintWriter easyOut = new PrintWriter( buffered );

      easyOut.println( "Hi Mom and Dad" );
      easyOut.println( "Please send " );
      easyOut.println( 5.03 );
      easyOut.println( "dollars");
      easyOut.println( true );
      easyOut.close();
      }
   }
Doc 17, Java IO Slide # 15

      Writer out = new FileWriter( "LetterHome");

      BufferedWriter buffered = new BufferedWriter( out);

      PrintWriter easyOut = new PrintWriter( buffered );

---

Doc 17, Java IO Slide # 16

class Test
   {
   public static void main( String args[] ) throws IOException
      {
      PrintWriter easyOut = new PrintWriter( 
                           new BufferedWriter( 
                              new FileWriter( "Example")
                              ) 
                           );

      easyOut.println( " Hi Mom" );
      easyOut.println( 5 );
      easyOut.println( true );
      easyOut.close();
      }
   }
Doc 17, Java IO Slide # 17

class  PrintStreamExample
   {
   public  static  void  main( String  args[] )
      {
      System.out.println(  "Hi Mom"  );
      }
   }

Flushes the print stream and returns whether or not there was an error on the output stream.

Doc 17, Java IO Slide # 18

Doc 17, Java IO Slide # 19

class Test
   {
   public static void main( String args[] ) throws IOException
      {
      System.out.println( System.getProperties() );
      }
   }

Doc 17, Java IO Slide # 20

Doc 17, Java IO Slide # 21

class  PoorPrint
   {
   String  name  =  "sam";
   }

class  FancyPrint
   {
   String  name  =  "pete";

   public  String  toString()
      {
      return  "FancyPrint( "  +  name  +  " )";
      }
   }

class  TestPrint
   {
   public  static  void  main( String  args[]  )
      {
      PoorPrint  outOfIt  =  new  PoorPrint();
      FancyPrint  cool  =  new FancyPrint();

      System.out.println(  outOfIt  );
      System.out.println( cool  );
      }
   }

Doc 17, Java IO Slide # 22

public void print( Object obj ) 
   {
   write(  String.valueOf( obj ) );
   }

public static String valueOf(Object obj) 
   {
   return (obj == null) ? "null" : obj.toString();
   }

public String toString() 
   {
   return getClass().getName() + "@" + 
         Integer.toHexString(hashCode());
   }
Doc 17, Java IO Slide # 23

Creates a new UnicodeReader.

Doc 17, Java IO Slide # 24

import java.io.*;
import sdsu.io.*;
class  ReadingFileExample
   {
   public  static  void  main( String  args[]  ) throws Exception
      {
      FileReader inputFile;
      BufferedReader bufferedFile;
      UnicodeReader cin;
      
      inputFile = new FileReader( "ReadingFileExample.java" );
      bufferedFile = new BufferedReader( inputFile );
      cin = new UnicodeReader( bufferedFile );

      System.out.println(  cin.readWord()  );

      for  ( int  k = 1 ;  k  <  4;  k++ )
         System.out.println(  cin.readLine()  );
      }
   }

import
 sdsu.io.*;
import java.io.*;
class  ReadingFileExample
Doc 17, Java IO Slide # 25

Doc 17, Java IO Slide # 26

public  static  void  main( String  args[]  ) throws Exception
   {
   Reader input = new StringReader( "hi mom how is dad?" );

   // UpperCaseReader is define on next slide

   input = new UpperCaseReader( input );

   UnicodeReader cin = new UnicodeReader( input );

   System.out.println(  cin.readWord()  );
   System.out.println(  cin.readLine()  );
   } 

HI
 MOM HOW IS DAD?
Doc 17, Java IO Slide # 27

class  UpperCaseReader extends FilterReader {
   public static final int EOF = -1;
   
   public UpperCaseReader( Reader input ) {
      super( input );
   }
      
   public int read() throws IOException {
      int nextChar = super.read();
      if ( nextChar == EOF )
         return EOF;
      else
         return toUpperCase( (char) nextChar );
   }
   
   public int read(char chars[], int offset, int length) throws 
                                    IOException  {
      int charsRead = super.read(chars, offset, length);
      
      if ( charsRead == EOF )
         return EOF;
         
      for ( int k = offset; k < offset + charsRead; k++)
         chars[ k ] = toUpperCase( chars[ k ] ) ;
      
      return charsRead;
   }

   private char toUpperCase( char convertMe ) {
      return Character.toUpperCase(  convertMe );
   }
}

Doc 17, Java IO Slide # 28

class StringWriterExample
   {
   public static void main( String args[] ) throws Exception
      {
      StringWriter outputString = new StringWriter();

      // see next slide for UpperCaseWriter

      UpperCaseWriter upperCaseOutput = 
                  new UpperCaseWriter( outputString);

      PrintWriter cout = new PrintWriter( upperCaseOutput );
      
      cout.println( "Hi Mom" );
      cout.println( 3.14);
      System.out.println( outputString.toString() );
      }
   }

Doc 17, Java IO Slide # 29

class  UpperCaseWriter extends FilterWriter {
   public static final int EOF = -1;
   
   public UpperCaseWriter( Writer output ) {
      super( output );  // input is stored in field "out"
   }
      
   public void write(int c) throws IOException {
      if ( c == EOF)
         super.write( c );
      else
         super.write( Character.toUpperCase( (char) c ));
   }
   
   public void write(char cbuf[], int off,  int len) throws    IOException  {
      write( new String( cbuf), off, len);
   }

   public void write(String str, int off,  int len) throws    IOException  {
      if ( len <= 0 )
         super.write( str, off, len);
      else
         super.write( str.toUpperCase(), off, len);
   }
}
Doc 17, Java IO Slide # 30

\064 -> \u0064

You may want 'a' to map to the "a" in Cyrillic

import java.io.InputStreamReader;
import java.io.InputStream;
import sdsu.io.UnicodeReader;

class Test
   {
   public static void main( String args[] )
      {
      InputStream in = System.in;
      
      InputStreamReader unicode = new InputStreamReader( in );
      UnicodeReader easyIn = new UnicodeReader( unicode );
      
      //Now you can use easyIn
      }
   }

Doc 17, Java IO Slide # 31

\u0064 -> \064

import java.io.OutputStreamWriter;
import java.io.OutputStream;
import java.io.PrintWriter;

class Test
   {
   public static void main( String args[] )
      {
      OutputStream out = System.out;
      
      OutputStreamWriter unicode = 
            new OutputStreamWriter( out );
      PrintWriter easyOut = new PrintWriter( unicode );
      
      //Now you can use easyOut
      }
   }
Doc 17, Java IO Slide # 32

compressed output using gzip format

decompressed gzip data

import java.io.*;
import sdsu.io.ASCIIInputStream;
import java.util.zip.GZIPOutputStream;
import java.util.zip.GZIPInputStream;

class Compressed
   {
   public static void main( String args[] ) throws IOException
      {
      OutputStream outputFile = 
         new FileOutputStream( "Compressed" );
      PrintWriter cout = 
         new PrintWriter (new GZIPOutputStream( outputFile ));
      cout.println("Hi Mom");
      cout.close();

      // the file "Compressed" now contains compress version of 
      // the string "Hi Mom"

      FileInputStream inputFile = 
            new FileInputStream( "Compressed" );
      ASCIIInputStream cin = 
         new ASCIIInputStream (
            new GZIPInputStream( inputFile ));
      System.out.println( cin.readLine());
      }
   }
Doc 17, Java IO Slide # 33

Closes the stream

Flushes the stream

Writes an array of bytes

Writes a sub array of bytes

Writes a byte

Doc 17, Java IO Slide # 34

class  CountSize  
   {
   public static void main( String args[] ) throws IOException
      {
      InputStream in;
      in = new StringBufferInputStream( "abcdefghij" );

      OutputStream out = System.out;
      
      int nextChar;
      
      while ( ( nextChar = in.read() ) != -1  )
         out.write(  Character.toUpperCase( (char) nextChar ) );

      out.write( '\n' );
      out.flush();
      }
   }

Doc 17, Java IO Slide # 35

Creates an input file with the specified system dependent file name.

Creates an input file from the specified File object.

Doc 17, Java IO Slide # 36

Creates an output file with the specified system dependent file name.

Creates an output file with the specified File object.

Doc 17, Java IO Slide # 37

Creates a new ASCIIInputStream.

Doc 17, Java IO Slide # 38

import java.io.*;
import sdsu.io.*;
class  ReadingFileExample
   {
   public  static  void  main( String  args[]  ) throws Exception
      {
      FileInputStream inputFile;
      BufferedInputStream bufferedFile;
      ASCIIInputStream  cin;
      
      inputFile = new FileInputStream( "ReadingFileExample.java" );
      bufferedFile = new BufferedInputStream( inputFile );
      cin = new ASCIIInputStream( bufferedFile );

      System.out.println(  cin.readWord()  );

      for  ( int  k = 1 ;  k  <  4;  k++ )
         System.out.println(  cin.readLine()  );
      }
   }

import
 sdsu.io.*;
import java.io.*;
class  ReadingFileExample
Doc 17, Java IO Slide # 39

public  static  void  main( String  args[]  ) throws Exception
   {
   InputStream input;
   ASCIIInputStream  cin;
   
   input = new StringBufferInputStream( "hi mom how is dad?" );
   input = new UpperCaseInputStream( input );   
   cin = new ASCIIInputStream( input );

   System.out.println(  cin.readWord()  );
   System.out.println(  cin.readLine()  );
   

HI
 MOM HOW IS DAD?
Doc 17, Java IO Slide # 40

class  UpperCaseInputStream extends FilterInputStream 
   {
   public static final int EOF = -1;
   
   public UpperCaseInputStream( InputStream input )
      {
      super( input );  // input is stored in field "in"
      }
      
   public int read() throws IOException
      {
      int nextChar = in.read();
      if ( nextChar == EOF )
         return EOF;
      else
         return toUpperCase( (char) nextChar );
      }
   
   public int read(byte bytes[], int offset, int length) throws 
                                    IOException 
      {
      int charsRead = in.read(bytes, offset, length);
      
      if ( charsRead == EOF )
         return EOF;
         
      for ( int index = offset; index < offset + charsRead; index++)
         bytes[ index ] = toUpperCase( (char) bytes[ index ] ) ;
      
      return charsRead;
      }

   protected byte toUpperCase( char convertMe ) {
      return (byte) Character.toUpperCase(  convertMe );
      }
   }

Doc 17, Java IO Slide # 41

import java.io.*;
class  WritingToFileExample
   {
   public  static  void  main( String  args[]  ) throws Exception
      {
      FileOutputStream outputFile;
      BufferedOutputStream bufferedFile;
      PrintStream   cout;
      
      outputFile = new FileOutputStream( "LetterHome" );
      bufferedFile = new BufferedOutputStream( outputFile );
      cout = new PrintStream( bufferedFile );
      
      cout.println( "Hi Mom" );
      cout.println( "How is Dad?" );
      cout.flush();
      cout.close();
      }
   }

visitors since 21-Oct-97