EE2E1.

JAVA Programming

Lecture 7

Files and Streams

Contents
Introduction - input and output streams
Exception handling
The stream class hierarchy
Simple file i/o
Layering streams reading/writing formatted files
Layering streams reading/writing gzip files
Reading and writing text files
Introduction - input and output
streams
Most applications require data to be stored in files
Spreadsheets
Word processing
etc
Java has extensive facilities for handling files of
various types
Associated with files is the general concept of
streams which can be applied to both files and
networks
 In Java, streams are simply sequences of bytes
We can read a byte stream from an input stream
object
We can write a byte stream to an output stream
object
Typically input and output stream objects can be
files but they also can be network connections
This generality means we can use the same
functions for accessing networks as reading
files
 Output stream object

byte stream

Input stream object

byte stream
 Java distinguishes between byte streams and
character streams
In Java, a character is represented by a 2-
byte Unicode character (www.unicode.org)
Reader object
character stream

Writer object
character stream
 Finally Java uses the concept of a data stream to
read and write useful data such as integers and
doubles (as opposed to just bytes and characters)
Java uses a mechanism called layering to attach
these different types of streams together
For example we can attach an input stream to a
file and then attach a data input stream to the
file input stream so we can read a file of
integers. (See later!)
The java.io package contains all of the classes for
input/output and streams
Its all quite complex because of its huge
flexibility
Its even worse than that because before we can use
streams we need to know about exceptions!!
Exception handling
All Java programs which deal with files and/or
streams must include exception handling
Exceptions are error conditions encountered in
executing class methods
Attempting to read past an end of file

Attempting to read a file that doesnt exist

Trying to open a malformed URL

Divide by zero

Taking the square root of a negative number

etc
 Normal error handling (in C) would return
an error code (eg. 1)
class myClass
{
.
.
public int readFile(.)
{
do
{
if (!end_of_file)
// read the file
else
return 1;
} while not_end_of_file
return number_of_bytes_read;
}
}
 This is a simple sometimes effective method but:
Sometimes not possible to return a valid error
code.
Not object oriented! No information about the
error is contained in the error code
Application code gets polluted with error
checking code
It would be nice to have all of the error
handling in one place
The method might not be able to return
normally from the error.
An example would be if a resource the
method was accessing was not available
 In Java, if an error occurs in a method, an
Exception object is thrown by the method
Any method that calls the first method

must catch the exception in an exception

handler and take appropriate action
After the exception is thrown and the

exception handler code executed, control

is not passed back to the caller
We dont have to worry about return

error codes
class myClass
{
.
.
public int myMethod
{
.
.
anObject.throwMethod(); // can throw an exception
.
return value; // normal return point
{
// Exception handler code
// Control passed to here if
// exception thrown
}
}
}
 Alternatively, the method calling throwMethod()
doesnt want to deal with the exception, so it
throws it on to the caller of myClass.myMethod()
to worry about
The exception can be thrown along a chain of
method calls until eventually one of the
methods decides to deal with it
It cant be ignored at the very least the outer
method call must deal with it!
class anotherClass
{
.
public int anotherMethod
{
.
.
myObject. myMethod(); // throws on the exception
.
.
return value; // normal return point
{
// Exception handler code
// Control passed to here if
// exception thrown
}
}
}
Throwing exceptions
A method must advertise the fact that it is going to
throw an exception of a specific type
For example some problem with I/O

Java differs from C++ in this respect

Exceptions are not typed in C++

Java uses the keyword throws to indicate that a

method can throw an exception
The method actually throws the exception using
the throw keyword
class myClass
{
.
.
public int myMethod throws IOException
{
.
if (some_IO_error_condition)
throw new IOException(); // throw exception object
.
}
}
Catching exceptions
If a method calls another method which throws an
exception, that exception must either be caught or
thrown on
If it is not, the program will terminate (non-
graphical, console applications)
or control will pass back to the user interface

processing loop (graphical applications/applets)

In both cases, an error message will be printed
 Exceptions are caught in a try/catch block
public aMethod
{
// method code which doesnt throw an exception
try
{
// code including a call to myClass.myMethod()
// which may throw an IOException
}
catch(IOException e)
{
// Exception handler code
}
} // method ends
 Execution of the above code is as follows
If the code inside the try block throws an
exception
The program skips the remainder of the code
in the try block
The program then proceeds to the code in the
catch block
If the code inside the try block doesnt throw
an exception
The program skips the code in the catch
block
 A finally clause after a catch block contains code
which is always executed irrespective if an
exception is caught or not
Quite often it is used to release a resource
which has been allocated in the try block
For all of this to work, the exception generated
must be of the type specified (in this case, an
IOException) in the catch clause
public aMethod
{
// method code which doesnt throw an exception
try
{
// Code which may throw an IOException
// Resource allocation
}
catch(IOException e)
{
// Exception handler code
}
finally
{
// Resource deallocation
// This code always executes
}
} // method ends
 Alternatively, the exception can be thrown on

public aMethod throws IOException

{
// method code including a call to myClass.myMethod()
// which may throw an IOException
}
Exception inheritance hierarchy
Exceptions are objects encapsulating information
about the type of error which caused the exception
All exception objects derive from Throwable
2 main types of exception object
RuntimeException

Usually a programmer error such as divide

by zero or trying to access an array beyond
its limits
IOException

Not generally caused by programmer error

and generally relating to I/O or network
errors
 Throwable

Exception

IOException RuntimeException

Creating exception classes
It is easy to create our own exceptions by
extending an existing exception class

public DivideByZeroException extends ArithmeticException

{
public DivideByZeroException(String Message)
{
super(message);
}
}
 The exception can then be thrown in the
usual way
class myClass
{
.
.
public double quotient(int num, int den)
throws DivideByZeroException
{
if (den==0)
throw new DivideByZeroException(Error!);
return ((double) num/(double)den);`
}
}
Example
The following program is a simple GUI enabling
integers to be inputted and their quotient
computed
Throws exceptions for
Incorrect integer format
NumberFormatException
Divide by zero
DivideByZeroException
 http://www.eee.bham.ac.uk/spannm/Java%2
0Stuff/ExceptionTestApplet/ExceptionTestAp
plet.html
Error dialog boxes are displayed when
exceptions are caught
Control then passes back to the event
handling loop
For a console based application, the
program would terminate after the
exceptions are caught
 DivideByZero exception thrown in the
method quotient() (which is part of the
graphics (Applet) container class)

public double quotient(int num, int den) throws

DivideByZeroException
{
if (den==0)
throw(new DivideByZeroException());
return (double) num/(double) den;
}
public void actionPerformed(ActionEvent evt)
{
try
{
int numerator=Integer.parseInt(inputNum.getText());
int denominator=Integer.parseInt(inputDen.getText());
double result=quotient(numerator,denominator);
outputQuotient.setText(precision.format(result));
}
catch(NumberFormatException e)
{
JOptionPane.showMessageDialog(this," Enter 2
integers","Invalid integer format!,
JOptionPane.ERROR_MESSAGE);
}
catch(DivideByZeroException e)
{
JOptionPane.showMessageDialog(this,"The
denominator must be non-zero",e.toString(),
JOptionPane.ERROR_MESSAGE);
}
}
 The exceptions are caught in the event
handler class (called when ENTER is
pressed from the output result text field)
Method quotient() throws the user
defined exception DivideByZero
exception
Method Integer.parseInt() throws the

NumberFormatException exception
Notice how there may be several catch()
clauses to catch multiple exceptions
The stream class hierarchy
Java has 2 abstract base classes, InputStream and
OutputStream for representing input and output
stream objects
InputStream and OutputStream are base classes
of a large hierarchy (more than 60!) of stream
classes
For example, classes FileInputStream and
FileOutputStream allow input and output streams
to be attached to files
Java also has 2 other abstract base classes, Reader
and Writer for handling Unicode character based
I/O
 InputStream

FileInputStream

OutputStream

FileOutputStream
Reader

Writer

Simple file i/o

The classes FileInputStream and
FileOutputStream give input and output to
streams attached to files
FileInputStream fin=new FileInputStream(myFile.dat);

This attaches an input stream to a named

file
Alternatively, we can use the File class
File f=new File(myFile.dat);
FileInputStream fin=new FileInputStream(f);
 byte stream
FileInputStream

myFile.dat
 FileInputStream has a method read() which
returns the byte read and 1 if it reaches the end of
the input stream
public int read() throws IOException

Similarly, FileOutputStream has a method write()

to write 1 byte to the output stream
Both read() and write() block the thread until
the byte is read or written
This often occurs when a network
connection is being accessed and it is busy
Example
The following program makes a straight copy of a
file and prints out the number of bytes copies
File names provided on the command line

java FileCopyTest input_file output_file

The FileInputStream constructor throws

an IOException if the file doesnt exist
FileInputStream.read() returns a 1 at
the end of file
We could call this method from our
own which throws an EOFException
import java.io.*;
public class FileCopyTest
{
public static void main(String[] args)
{
String inFile=args[0];
String outFile=args[1];
int nbytes=0;
try
{
FileInputStream fin=new FileInputStream(inFile);
FileOutputStream fout=new FileOutputStream(outFile);
int b=fin.read();
do
{
fout.write(b);
nbytes++;
b=fin.read();
} while (b!=-1);
}
catch (IOException e) { System.out.println("i/o problem!");}
System.out.println(nbytes + " bytes copied");
}
}
Layering streams
reading/writing formatted files
We often want to read files containing formatted
data
For example, a file of integers or doubles
Our FileInputStream has no methods which return
numeric types it can only read bytes
We need to combine our FileInputStream and
FileOutputStream objects with other types of
stream objects in order to read formatted files
A combination of different stream types are
known as filtered streams
 A DataInputStream object can be attached
to a FileInputStream object as follows

FileInputStream fin=new FileInputStream(myFile.dat);

DataInputStream din=new DataInputStream(fin);
din.readDouble();
.
.
formatted
input stream DataInputStream FileInputStream

Formatted file
Example
The following program writes integers and
doubles to a file and then reads them back
Uses DataInputStream.readInt() and
DataInputStream.readDouble() for
reading
Uses DataOutputStream.writeInt() and
DataOutputStream.writeDouble() for
writing
Catches an end of file exception
public class FormattedFileTest
{
public static void main(String[] args)
{
String fname=args[0];
try
{
FileOutputStream fout=new FileOutputStream(fname);
DataOutputStream dout=new DataOutputStream(fout);
for (int i=0; i<100; i++)
{ dout.writeInt(i); dout.writeDouble(i*0.5); }
}
catch (IOException e) { System.out.println("i/o problem!");}
try
{
FileInputStream fin=new FileInputStream(fname);
DataInputStream din=new DataInputStream(fin);
for (int j=0; j<150; j++)
{ int i=din.readInt(); double d=din.readDouble(); }
}
catch (EOFException e) { System.out.println("EOF!");}
catch (IOException e) { System.out.println("i/o problem!");}
}
}
Layering streams
reading/writing gzip files
A Java program can read/write gzipped (and
zipped) compressed files using stream
layering
Classes GZIPInputStream and
GZIPOutputStream enable i/o to be
performed on gzipped files
Similarly, classes ZipInputStream and
ZipOutputStream allow i/o on zipped files
 We can add a gzipped input stream to our
previous example enabling us to read
formatted data from a gzipped file!

gzipped
DataInputStream GZIPInputStream
input stream

FileInputStream
Zip file
 The following code segment shows how the
file created in the previous example can be
read after gzipping
A file is gzipped using the UNIX
command gzip filename
.
try
{
FileInputStream fin=new FileInputStream(fname);
GZIPInputStream gin=new GZIPInputStream(fin);
DataInputStream din=new DataInputStream(gin);
for (int j=0; j<150; j++)
{ int i=din.readInt(); double d=din.readDouble(); }
}
catch (EOFException e) { System.out.println("EOF!");}
catch (IOException e) { System.out.println("i/o problem!");}
.
.
Reading and writing text files
All of our classes so far have been for binary files
Data is stored in files as bytes which is efficient
but not humanly readable
A text file consists of information stored in
humanly readable form
For example the number 150 would be stored
as 1 5 0 instead of the binary representation
of 150 (10010110)
Java has a number of classes (descended from the
abstract Reader and Writer classes) for handling
text i/o
Outputting to a text file
This can easily be done with the PrintStream
class
Both text and numeric data can be output
using the print() and println() methods
Contains overloaded methods print(char
c), print(int i), print(double d), etc
Uses a filter class (FilterOutputStream) to
convert from Unicode to readable characters
 The following program segment outputs string and
numeric text to a text file
Be clear about the difference between this and

the previous program using a binary file

.
try
{
FileOutputStream fout=new FileOutputStream(fname);
PrintStream out=new PrintStream(fout,true);
out.println(Output data coming up);
for (int j=0; j<150; j++)
{
out.print(j);
out.println(j*0.5);
}
}
catch (IOException e) { System.out.println("i/o problem!");}
.
Console-based input
Reading data input from the command line
in Java is not easy
The System class has standard output, input
and error (just like C) which are already
open when the program executes
These can be used in console-based i/o
 class System
{
private
static InputStream in;
static PrintStream out;
static PrintStream err;
.
.
.
}

Console based output is easy

We can use the methods of PrintStream

.
System.out.println(Hello World!);
System.out.println(x= + x);
.
 Console based input is more difficult
A class Console has been written by the
authors of the Core Java book providing
convenient input methods
readLine() returns a string

readInt() returns an integer

readDouble() returns a double

readInt() and readDouble() use

readLine() to read an input string and use
string parsing to extract the numerical
value
public class Console
{
public static readLine()
{ reads a string from the keyboard}

public static double readDouble(string prompt)

{ reads a double from the keyboard }
public static readInt(String prompt)
{ reads an integer from the keyboard}
}
public static String readLine()
{ int ch;
String r = "";
boolean done = false;
while (!done)
{ try
{ ch = System.in.read();
if (ch < 0 || (char)ch == '\n')
done = true;
else if ((char)ch != '\r') r = r + (char) ch;
}
catch(java.io.IOException e)
{ done = true;
}
}
return r;
}
 The class is used as follows :

import Console.*;
class ConsoleTest
{
static void main(String args[])
{
int i=Console.readInt("Input an integer: ");
double d=Console.readDouble("Input a double: ");
System.out.println("Values entered= "+ i + " " + d);
}
}
And finally
Java handling of files and streams is extensive
We have only just scratched the surface!

Lots of other facilities are provided within the

various classes
Buffered i/o

Random access files

Object streams serialization

See chapter 12 in Core Java (Vol. 1)