Simple Java I/O

Part I
General Principles
 Streams
• All modern I/O is stream-based
• A stream is a connection to a source of data or to a
destination for data (sometimes both)
• An input stream may be associated with the keyboard
• An input stream or an output stream may be
associated with a file
• Different streams have different characteristics:
– A file has a definite length, and therefore an end
– Keyboard input has no specific end
 How to do I/O
import java.io.*;

• Open the stream

• Use the stream (read, write, or both)
• Close the stream
open
use
close Why Java I/O is hard
• Java I/O is very powerful, with an
overwhelming number of options
• Any given kind of I/O is not particularly
difficult
• The trick is to find your way through the
maze of possibilities
open
use
close Opening a stream
• There is data external to your program that
you want to get, or you want to put data
somewhere outside your program
• When you open a stream, you are making a
connection to that external place
• Once the connection is made, you forget
about the external place and just use the
stream
open
use
close Example of opening a stream
• A FileReader is a used to connect to a file
that will be used for input:
FileReader fileReader =
new FileReader(fileName);
• The fileName specifies where the
(external) file is to be found
• You never use fileName again; instead,
you use fileReader
open
use
close Using a stream
• Some streams can be used only for input,
others only for output, still others for both
• Using a stream means doing input from it or
output to it
• But it’s not usually that simple--you need to
manipulate the data in some way as it
comes in or goes out
open
use
close Example of using a stream
int ch;
ch = fileReader.read( );

• The fileReader.read() method reads one

character and returns it as an integer, or -1
if there are no more characters to read
• The meaning of the integer depends on the
file encoding (ASCII, Unicode, other)
open
use
close Manipulating the input data
• Reading characters as integers isn’t usually
what you want to do
• A BufferedReader will convert integers to
characters; it can also read whole lines
• The constructor for BufferedReader takes
a FileReader parameter:
BufferedReader bufferedReader =
new BufferedReader(fileReader);
open
use
close Reading lines

String s;
s = bufferedReader.readLine( );

• A BufferedReader will return null if there is

nothing more to read
open
use
close Closing
• A stream is an expensive resource
• There is a limit on the number of streams
that you can have open at one time
• You should not have more than one stream
open on the same file
• You must close a stream before you can
open it again
• Always close your streams!
 Simple Java I/O

Part II
LineReader and LineWriter
 Text files

• Text (.txt) files are the simplest kind of files

– text files can be used by many different programs
• Formatted text files (such as .doc files) also
contain binary formatting information
• Only programs that “know the secret code”
can make sense formatted text files
• Compilers, in general, work only with text
 My LineReader class

class LineReader {
BufferedReader bufferedReader;

LineReader(String fileName) {...}

String readLine( ) {...}

void close( ) {...}

}
 Basics of the LineReader
constructor
• Create a FileReader for the named file:
FileReader fileReader =
new FileReader(fileName);
• Use it as input to a BufferedReader:
BufferedReader bufferedReader =
new BufferedReader(fileReader);
• Use the BufferedReader; but first, we need
to catch possible Exceptions
The full LineReader constructor

LineReader(String fileName) {
FileReader fileReader = null;
try { fileReader = new FileReader(fileName); }
catch (FileNotFoundException e) {
System.err.println
("LineReader can't find input file: " + fileName);
e.printStackTrace( );
}
bufferedReader = new BufferedReader(fileReader);
}
 readLine

String readLine( ) {
try {
return bufferedReader.readLine( );
}
catch(IOException e) {
e.printStackTrace( );
}
return null;
}
 close

void close() {
try {
bufferedReader.close( );
}
catch(IOException e) { }
}
 How did I figure that out?

• I wanted to read lines from a file

• I found a readLine method in the
BufferedReader class
• The constructor for BufferedReader takes a
Reader as an argument
• An InputStreamReader is a kind of Reader
• A FileReader is a kind of InputStreamReader
 The LineWriter class

class LineWriter {
PrintWriter printWriter;

LineWriter(String fileName) {...}

void writeLine(String line) {...}

void close( ) {...}

}
 The constructor for LineWriter

LineWriter(String fileName) {
try {
printWriter =
new PrintWriter(
new FileOutputStream(fileName), true);
}
catch(Exception e) {
System.err.println("LineWriter can't " +
"use output file: " + fileName);
}
}
 Flushing the buffer

• When you put information into a buffered

output stream, it goes into a buffer
• The buffer may not be written out right away
• If your program crashes, you may not know
how far it got before it crashed
• Flushing the buffer is forcing the
information to be written out
 PrintWriter
• Buffers are automatically flushed when the
program ends normally
• Usually it is your responsibility to flush
buffers if the program does not end normally
• PrintWriter can do the flushing for you
public PrintWriter(OutputStream out,
boolean autoFlush)
 writeLine

void writeLine(String line) {

printWriter.println(line);
}
 close

void close( ) {
printWriter.flush( );
try { printWriter.close( ); }
catch(Exception e) { }
}
Simple Java I/O

Part III
FileDialogs
 About FileDialogs
• The FileDialog class displays a window from
which the user can select a file
• The FileDialog window is modal--the
application cannot continue until it is closed
• Only applications, not applets, can use a
FileDialog; only applications can access files
• Every FileDialog window is associated with
a Frame
Typical FileDialog window
 FileDialog constructors
• FileDialog(Frame f)
– Creates a FileDialog attached to Frame f
• FileDialog(Frame f, String title)
– Creates a FileDialog attached to Frame f, with the
given title
• FileDialog(Frame f, String title, int type)
– Creates a FileDialog attached to Frame f, with the
given title; the type can be either FileDialog.LOAD or
FileDialog.SAVE
 Useful FileDialog methods I
• String getDirectory()
– Returns the selected directory
• String getFile()
– Returns the name of the currently selected file,
or null if no file is selected
• int getMode()
– Returns either FileDialog.LOAD or
FileDialog.SAVE, depending on what the
dialog is being used for
 Useful FileDialog methods II
• void setDirectory(String directory)
– Changes the current directory to directory
• void setFile(String fileName)
– Changes the current file to fileName
• void setMode(int mode)
– Sets the mode to either FileDialog.LOAD or
FileDialog.SAVE
 Using a FileDialog
• Using a FileDialog isn’t difficult, but it is
lengthy
• See my LineReader class (in the
Encryption assignment) for a complete
example
Simple Java I/O

Part IV
Serialization
 Serialization
• You can also read and write objects to files
• Object I/O goes by the awkward name of
serialization
• Serialization in other languages can be very
difficult, because objects may contain
references to other objects
• Java makes serialization (almost) easy
 Conditions for serializability
• If an object is to be serialized:
– The class must be declared as public
– The class must implement Serializable
– The class must have a no-argument constructor
– All fields of the class must be serializable:
either primitive types or serializable objects
 Implementing the Serializable
interface
• To “implement” an interface means to define all
the methods declared by that interface, but...
• The Serializable interface does not define any
methods!
– Question: What possible use is there for an interface
that does not declare any methods?
– Answer: Serializable is used as flag to tell Java it
needs to do extra work with this class
open
use
close Writing objects to a file

ObjectOutputStream objectOut =
new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream(fileName)));

objectOut.writeObject(serializableObject);

objectOut.close( );
open
use
close Reading objects from a file

ObjectInputStream objectIn =
new ObjectInputStream(
new BufferedInputStream(
new FileInputStream(fileName)));

myObject = (itsType)objectIn.readObject( );

objectIn.close( );
 What have I left out?
• Encrypted files, compressed files, files sent
over internet connections, ...
• Exceptions! All I/O involves Exceptions!
• try { statements involving I/O }
catch (IOException e) {
e.printStackTrace ( );
}
The End