Managing Input /
Output Files in Java
Copyright © 2009 by Royal Institute of Information Technology
Copyright © 2009 by Royal Institute of Information Technology
Introduction
A file is a collection of related records placed in a
particular area on the disk
A record is composed of several fields
A field is a group of characters.
Characters in java are Unicode characters
composed of two bytes.
Each Byte containing eight binary digits, 1 or 0
Storing and Managing data using files is known as
file processing which includes tasks such as
Copyright © 2009 by Royal Institute of Information Technology
Concept of Streams
Java uses the concept of streams to represent the
ordered sequence of data
A common characteristic shared by all the Input /
Output devices.
A stream presents a uniform, easy-to-use, object-
oriented interface between the program and the
Input / Output devices.
Stream has a source (of data) and a destination
(for that data) may be physical devices or programs
or other streams in the program
Copyright © 2009 by Royal Institute of Information Technology
Relationship of Java program
with I/O devices
Sources Destinations
Keyboard Screen
Mouse Printer
Java
Memory program Memory
Disk Disk
Input Output
Network Network
Copyright © 2009 by Royal Institute of Information Technology
Using input and Output Streams
Java streams are classified into two basic types,
namely, input stream and output stream
Input stream
Reads
Source Program
(a) Reading data into a program
Output stream
Writes
Program Destination
(b) Writing data into a destination
Copyright © 2009 by Royal Institute of Information Technology
Stream Classes
The java.io package contains a large number of
stream classes that provide capabilities for
processing all type of data.
These classes may be categorized into two groups
Byte stream classes that provide support for
handling I/O operations on bytes.
Character stream classes that provide support
for managing I/O operations on characters.
Copyright © 2009 by Royal Institute of Information Technology
Classification of Java stream
classes Java
Stream Classes
Byte Stream Character Stream
Classes Classes
Input Stream Output Stream Reader Writer
Classes Classes Classes Classes
Memory File Pipe Memory File Pipe
Copyright © 2009 by Royal Institute of Information Technology
Byte Stream Classes
Byte stream classes have been designed to provide
functional features for creating and manipulating
streams and files for reading and writing bytes.
Java provides two kinds of byte stream classes :
input stream classes
output stream classes
Copyright © 2009 by Royal Institute of Information Technology
Input Stream Classes
Input stream classes that are used to read 8-bit
bytes include a super class known as
InputStream.
The super class InputStream is an abstract class,
and, therefore we cannot create instances of this
class.
Rather, we must use the subclasses that inherits
from this class.
Hierarchy of input stream classes
Copyright © 2009 by Royal Institute of Information Technology
File
InputStream
FileInputStream SequenceInputStream
PipeInputStream ObjectInputStream
ByteArrayInputStream StringBufferInputStream
FilterInputStream
DataInputStream
DataInput
Copyright © 2009 by Royal Institute of Information Technology
Summary of InputStream Methods
Method Description
read() Reads a byte from the input stream
read(byte b[ ]) Reads an array of bytes into b
read(byte b[ ], int n, int m) Reads m bytes into b starting from nth byte
available() Gives number of bytes available in the input
skip(n) Skips over n bytes from the input stream
reset() Goes back to the beginning of the stream
close() Closes the input stream
(Continued)
Copyright © 2009 by Royal Institute of Information Technology
Summary of InputStream Methods
(Continued)
• The class DataInputStream extends
FilterInputStream and Implements the
interface DataInput.
• Therefore, the DataInputStream class
implements the methods described in DataInput
• DataInput interface contains
readShort()
readInt()
readLong()
Copyright © 2009 by Royal Institute of Information Technology
Output Stream Classes
Output stream classes are derived from the base
class OutputStream
Like InputStream, the OutputStream is an
abstract class and therefore we cannot instantiate
it.
The several subclasses of the OutputStream can
be used for performing the output operations.
Hierarchy of output stream
Copyright © 2009 by Royal Institute of Information Technology
classes Object
OutputStream
FileOutputStream ObjectOutputStream
PipedOutputStream ByteArrayOutputStream
FilterOutputStream
BufferedOutputStream PushbackOutputStream
DataOutputStream
DataOutput
Copyright © 2009 by Royal Institute of Information Technology
Summary of OutputStream
Methods
Method Description
write() Writes a byte from the input stream
write(byte b[ ]) Writes all bytes in the array of b to the output
stream
write(byte b[ ], int n, int m) Writes m bytes into b starting from nth byte
close() Close the output Stream
flush() Flushes the Output Stream
(Continued)
Copyright © 2009 by Royal Institute of Information Technology
Summary of OutputStream
Methods (Continued)
• The class DataOutputStream, a counterpart of
DataInputStream, implements the interface
DataOutput.
• Therefore, implements the following methods
contained in DataOutput interface.
writeShort()
writeInt()
writeLong()
Copyright © 2009 by Royal Institute of Information Technology
Character Stream Classes
Character stream classes were not a part of the
language when it was released in 1995.
They were added when the version 1.1 was announced.
Character streams can be used to read and write 16-bit
Unicode characters.
There are two kind of character stream classes
Reader Stream Classes
Writer Stream Classes
Copyright © 2009 by Royal Institute of Information Technology
Reader Stream Classes
Reader stream classes are designed to read
character from the files.
Reader class is the base class for all other classes
in this group.
The Reader class contains methods that are
identical to those available in the InputStream
class, except Reader is designed to handle
characters.
Reader class can perform all the functions
implemented by the input stream classes
Hierarchy of reader stream
Copyright © 2009 by Royal Institute of Information Technology
classes Object
Reader
BufferedReader StringReader
CharArrayReader PipeReader
InputStreamReader FilterReader
FileReader PushbackReader
Copyright © 2009 by Royal Institute of Information Technology
Writer Stream Classes
The writer stream classes are designed to perform
all output operations on files.
Only difference is that while output stream classes
are designed to write bytes, the writer stream
classes are designed to write characters
The Writer class is an abstract class which acts as
a base class for all other writer stream classes.
Hierarchy of writer stream
Copyright © 2009 by Royal Institute of Information Technology
classes Object
Writer
BufferedWriter PrintWriter
CharArrayWriter StringWriter
FilterWriter PipeWriter
OutputStreamWriter
FileWriter
Copyright © 2009 by Royal Institute of Information Technology
Other Useful I/O Classes
The java.io package supports many other classes
for performing certain specialized functions.
RandomAccessFile
StreamTokenizer
Copyright © 2009 by Royal Institute of Information Technology
RandomAccessFile
The RandomAccessFile enables us to read and
write bytes, text and Java data types to any location
in a file.
This class extends object class and implements
DataInput and DataOutput interface.
This forces the RandomAccessFile to
implement the methods described in both these
interfaces
Copyright © 2009 by Royal Institute of Information Technology
Implementation of the
RandomAccessFile
Object
Interface Interface
DataInput DataOutput
RandomAccessFile
Copyright © 2009 by Royal Institute of Information Technology
StreamTokenizer
The class StreamTokenizer, a subclass of
object can be used for breaking up a stream of text
from an input text file into meaningful pieces
called tokens.
The behavior of the StringTokenizer class is
similar to that of the StringTokenizer class (of
java.util package) that breaks into its component
tokens.
Copyright © 2009 by Royal Institute of Information Technology
Using the File Class
The java.io package includes a class known as the
File class that provides support for creating files
and directories.
The class also contains several methods.
Creating a file
Opening a file
Closing a file
Deleting a file
Copyright © 2009 by Royal Institute of Information Technology
Important I/O Exception Classes
I/O Exception class Function
EOFException Signals that an end of the file or end of stream has
been reached unexpectedly during input
FileNotFoundException Informs that a file could not be found
InterruptedIOException Warns that an I/O operations has been
interrupted
IOException Signals that an I/O exception of some sort has
occurred
Copyright © 2009 by Royal Institute of Information Technology
Common Stream Classes used for
I/O Operations
Source Characters Bytes
Read Write Read Write
Memory CharArrayReader CharArrayReader ByteArrayInputStream ByteArrayOutputStream
File FileReader FileWriter FileInputStream FileOutputStream
Pipe PipedReader PipedWriter PipedInputStream PipedOutputStream
Copyright © 2009 by Royal Institute of Information Technology
Instantiating file stream objects
fis “test.dat”
Stream object Filename
fis inFile “test.dat”
Stream object File object Filename
Copying Characters Copyright © 2009 by Royal Institute of Information Technology
import java.io.*;
class CopyCharacters{
public static void main(String args[ ]){
File inFile = new File(“input.dat”);
File outFile = new File(“output.dat”);
FileReader ins = null;
FileWriter outs = null;
try{
ins = new FileReader(inFile);
outs = new FileWriter(outFile);
int ch;
while( (ch = ins.read()) != -1){
outs.write(ch);
}
Reading from and Writing to files
ins stream
input.dat
read()
inFile
Program
output.dat write()
outFile outs stream
Copyright © 2009 by Royal Institute of Information Technology
Writing bytes to a file
import java.io.*;
class WriteBytes{
public static void main(String args[]){
byte cities[] = {‘D’, ‘E’, ‘L’, ‘H’, ‘I’, ‘\n’, ‘M’, ‘A’, ‘D’, ‘R’, ‘A’, ‘S’, ‘\n’, ‘L’, ‘O’, ‘N’, ‘D’, ‘O’, ‘N’, ‘\n’ };
FileOutputStream outfile = null;
try{
outfile = new FileOutputStream (“city.txt”);
outfile.write(cities);
outfile.close();
}
catch(IOException ioe){
System.out.println(ioe);
System.out.println(-1);
}
}
}
Reading Bytes from a file
Copyright © 2009 by Royal Institute of Information Technology
import java.io.*;
class ReadBytes{
public static void main(String args[]){
FileInputStream infile = null;
int b;
try{
infile = new FileInputStream(args[0]);
while((b = infile.read()) != -1){
System.out.print((char) b);
}
infile.close();
}
catch(IOException ioe){
System.out.println(ioe);
}
}
}
Copying bytes from one file to
Copyright © 2009 by Royal Institute of Information Technology
another
import java.io.*;
class CopyBytes{
public static void main(String args[]){
FileInputStream infile = null;
FileOutputStream outfile = null;
byte byteRead;
try{
infile = new FileInputStream(“in.dat”);
outfile = new FileOutputStream (“out.dat”);
Program Continued
Copyright © 2009 by Royal Institute of Information Technology
catch(FileNotFoundException e){
System.out.println(“File not Found”);
}
catch(IOException e){
System.out.println(e.getMessage());
}
finally{
try{
infile.close();
Copyright © 2009 by Royal Institute of Information Technology
Handling Primitive Data Types
To read/write the primitive data types, we can use
filter classes as wrappers on existing input and
output streams to filter data in the original stream.
The two filter classes used for creating “data
streams” for handling primitive types are
DataInputStream and DataOutputStream.
Copyright © 2009 by Royal Institute of Information Technology
Hierarchy of Data Stream classes
Class Interface
FilterInputStream DataInput
DataInputStream
Interface Class
DataOutput FilterOutputStream
DataOutputStream
Reading and Writing primitive
Copyright © 2009 by Royal Institute of Information Technology
data
import java.io.*;
class ReadWritePrimitive{
public static void main(String args[]) throws IOException{
File primitive = new File(“prim.dat”);
FileOutputStream fos = new FileOutputStream(primitive);
DataOutputStream dos = new DataOutputStream(fos);
//Write primitive data to the “prim.dat” file
dos.writeInt(1999);
dos.writeDouble(375.85);
dos.writeChar(‘X’);
dos.close();
fos.close(); (Continued)
Copyright © 2009 by Royal Institute of Information Technology
Program (Continued)
//Read data from to the “prim.dat” file
FileInputStream fis = new FileInputStram(primitive);
DataInputStream dis = new DataInputStream(fis);
System.out.println(dis.readInt());
System.out.println(dis.readDouble());
System.out.println(dis.readBoolean());
System.out.println(dis.readChar());
dis.close();
fis.close();
}
}
Using a Single file for storing and retrieving
Copyright © 2009 by Royal Institute of Information Technology
import java.io.*;
class ReadWriteIntegers{
public static void main(String args[]){
// Declare data streams
DataInputStream dis = null;
DataOutputStream dos = null;
// Construct a file
File inFile = new File(“rand.dat”);
// Writing integers to rand.dat file
try{
dos = new DataOutputStream(new
Program (Continued) Copyright © 2009 by Royal Institute of Information Technology
catch(IOException ioe){
System.out.println(ioe.getMessage());
finally{
try{
dos.close();
catch(IOException ioe) { }
try{
dis = new DataInputStream(new FileInputStream(inFile));
for(int i=0; i<20; i++){
int n = dis.readInt();
System.out.print(n + “ ”);
catch(IOException ioe){
System.out.println(ioe.getMessage());
finally{
try{
dis.close();
catch(IOException ioe) { }
}
Copyright © 2009 by Royal Institute of Information Technology
Concatenating and Buffering Files
Combine two or more input streams (files) into a
single input stream(file). This process is known as
concatenation of file.
It is achieved using the SequenceInputStream
class.
Creation of buffers to store temporarily data that is
read from or written to a stream. This process is
known as buffered i/o operation.
Buffers can be created using the
BufferedInputStream and
Copyright © 2009 by Royal Institute of Information Technology
IIIustration of concatenation and
Buffering
file 1 inBuffer
file1 + file2
file 2 read()
file3
Program
outBuffer write()
Screen
System.out
Program of Concatenation and
Copyright © 2009 by Royal Institute of Information Technology
Buffering
import java.io.*;
class SequenceBuffer{
public static void main(String args[]) throws IOException{
//Declare file streams
FileInputSteram file1 = null;
FileInputStream file2 = null;
//Declare file3 to store combined files
SequenceInputStream file3 = null;
file1 = new FileInputStream(“text1.dat”);
file2 = new FileInputStream(“text2.dat”);
Program (Continued)
Copyright © 2009 by Royal Institute of Information Technology
BufferedInputStream inBuffer = new
BufferedInputStream(file3);
BufferedOutputStream outBuffer = new
BufferedOutputStream(System.out);
//Read and Write till the end of buffers
int ch;
while ((ch = inBuffer.read()) != -1){
outBuffer.write((char) ch);
}
inBuffer.close();
outBuffer.close();
Random Access Files Copyright © 2009 by Royal Institute of Information Technology
RandomAccessFile class supported by the java.io
package allows us to create files that can be used for
reading and writing data with random access.
A file can be created and opened for random access by
giving a mode string as a parameter to the constructer
when we open file.
“r” for reading only
“rw” for both reading and writing
Random access files support a pointer known as file
pointer that can be moved to arbitrary positions in the file
prior to reading or writing.
The file pointer is moved using the method seek() in the
RandomAccessFile class.
Reading/Writing using a random access file
Copyright © 2009 by Royal Institute of Information Technology
import java.io.*;
class RandomIO{
public static void main(String args[]) throws IOException{
RandomAccessFile file = null;
try{
file = new RandomAccessFile(“rand.dat”, “rw”);
file.WriteChar(‘X’);
file.writeInt(555);
file.writeDouble(3.1412);
file.seek(0); //Go to the beginning
System.out.println(file.readChar());
Program (Continued)
Copyright © 2009 by Royal Institute of Information Technology
file.seek(2) // Go to the second item
System.out.println(file.readInt());
// Go to the end and append false to the file
file.seek(file.length());
file.writeBoolean(false);
file.seek(4);
System.out.println(file.readBoolean());
file.close();
}
catch(IOException e){
Copyright © 2009 by Royal Institute of Information Technology
Appending to an existing file
import java.io.*;
class RandomAccess{
static public void main(String args[]){
RandomAccessFile rFile;
try{
rFile = new RandomAccessFile(“city.txt”, “rw”);
rFile.seek(rFile.length());
rFile.writeBytes(“MUMBAI/n”);
rFile.close();
}
Interactive input and output
Copyright © 2009 by Royal Institute of Information Technology
import java.util.*;
import java.io.*;
class Inventory{
static DataInputStream din = new DataInputStream(System.in);
static StringTokenizer st;
public static void main(String args[]) throws IOException{
DataOutputStream dos = new DataOutputStream(new FileOutputStream(“invent.dat”));
System.out.println(“Enter code number”);
st = new StringTokenizer(din readLine());
int code = Integer.parseInt(st.nextToken());
System.out.println(“Enter number of items”);
st = new StringTokenizer(din.readLine());
int items = Integer.parseInt(st.nextToken());
(Continued)
Program (Continued) Copyright © 2009 by Royal Institute of Information Technology
System.out.println(“Enter cost”);
st = new StringTokenizer(din.readLine());
double cost = new Double(st.nextToken()).doubleValue();
dos.writeInt(code);
dos.writeInt(items);
dos.writeDouble(cost);
dos.close();
DataInputStream dis = new DataInputStream(new
FileInputStream(“invent.dat”));
int codeNumber = dis.readInt();
int totalItems = dis.readInt();
double itemCost = dis.readDouble();
double totalCost = totalItems * itemCost;
dis.close();
System.out.println();
System.out.println(“Code Number : ”+ codeNumber);
System.out.println(“Item Cost : ”+ itemCost);
System.out.println(“Total Items :”+ totalItems);
System.out.println(“Total Cost :”+ totalCost);
}
}
Copyright © 2009 by Royal Institute of Information Technology
Output of the Program
Enter code number
1001
Enter number of items
193
Enter cost
452
Code Number : 1001]
Copyright © 2009 by Royal Institute of Information Technology
Creating a file using text fields in
windows
import java.io.*;
import java.awt.*;
class StudentFile extends Frame{
//Defining window components
TextField number, name, marks;
Button enter, done;
Label numLabel, nameLabel, markLabel;
DataOutputStream dos;
//Initialize the Frame
public StudentFile(){
super(“Create Student File”);
//Setup the window
public void setup(){
resize(400, 200);
setLayout(new GridLayout (4, 2));
number = new TextField(25);
numLabel = new Label(“Roll Number”);
name = new TextField(25);
nameLabel = new Label(“Student name”);
marks = new TextField(25);
markLabel = new Label(“Marks”);
enter = new Button(“ENTER”);
done = new Button(“DONE”);
(Continued)
Program (Continued) Copyright © 2009 by Royal Institute of Information Technology
//Add the components to the Frame
add(numLabel);
add(number);
add(nameLabel);
add(name);
add(markLabel);
add(marks);
add(enter);
add(done);
show();
//open the file
try{
dos = new DataOutputStream(new FileOutputStream(“student.dat”));
catch(IOException e){
System.err.println(e.toString());
System.exit(1);
//Write to the file
public void addRecord(){
int num;
Double d;
num = (new Integer (number.getText())).intValue();
(Continued)
Program (Continued) Copyright © 2009 by Royal Institute of Information Technology
try{
dos.writeInt(num);
dos.writeUTF(name.getText());
d = new Double(marks.getText());
dos.writeDouble(d.doubleValue());
catch(IOException e) { }
//clear the text fields
number.setText(“ ”);
name.setText(“ ”);
marks.setText(“ ”);
//Adding the record and clearing the
public void cleanup(){
if(! number.getText().equals(“ “)){
addRecord();
try{
dos.flush();
dos.close();
catch(IOException e) { }
(Continued)
Program (Continued) Copyright © 2009 by Royal Institute of Information Technology
//Processing the event
public boolean action (Event event, object o){
if(event.teg instanceof Button){
if(event.arg.equals(“ENTER”)){
addRecord();
return true;
return super.action(event, o);
public boolean handleEvent(Event event){
if(event.get instanceof Button){
if(event.arg.equals(“DONE”)){
cleanup();
System.exit(0);
return true;
return super.handleEvent(event);
//Execute the program
public static void main(String args[]){
StudentFile student = new StudentFile();
student.setup();
}
Copyright © 2009 by Royal Institute of Information Technology
Output of the Program
Copyright © 2009 by Royal Institute of Information Technology
Other Stream Classes
Object Streams
Piped Streams
Pushback Streams
Filtered Streams
Copyright © 2009 by Royal Institute of Information Technology
Object Streams
It is also possible to perform input and output
operations on objects using the object streams.
The object streams are created using
ObjectInputStream and ObjectOutputStream
classes.
We may declare records as objects and use the object
classes to write and read these objects from files.
This process is known as object serialization.
Copyright © 2009 by Royal Institute of Information Technology
Piped Streams
Piped streams provide functionality for threads to
communicate and exchange data between them.
The write thread sends data to the read thread
through a pipeline that connects an object of
PipedInputStream to an object of
PipedOutputStream.
The objects inputPipe and outputPipe are
connected using the connect() method.
Copyright © 2009 by Royal Institute of Information Technology
Threads using pipes to
communicate
inputPipe outputPipe
Write Thread Read Thread
Copyright © 2009 by Royal Institute of Information Technology
Pushback Streams
The pushback streams created by the classes
PushbackInputStream and
PushbackReader can be used to push a single
byte or a character back into the input stream so
that it can be reread.
When a character indicating a new input token is
read, it is pushed back into the input stream until
the current input token is processed.
Copyright © 2009 by Royal Institute of Information Technology
Filtered Streams
Java supports two abstract classes, namely,
FilterInputStream and FilterOutputStream that
provides the basic capability to create input and output
streams for filtering input/output in a number of ways.
These streams, known as Filters, sit between an input
stream and an output stream and perform some
optional processing on the data they transfer
Input Output
stream stream
Filter 1 Filter 2 Filter 3
