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
creating, updating files and manipulation of data
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
Keyboard Screen

Mouse Printer
Mouse Printer
Java
Memory program Memory
Memory Memory

Disk Disk
Disk Disk
Input Output
Network Network
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
Source Program

(a) Reading data into a program

Output stream
Writes
Program Destination
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
StreamJava
Classes
Stream Classes

Byte Stream Character Stream

Byte Stream
Classes Character
ClassesStream
Classes Classes

Input Stream Output Stream Reader Writer

Input Stream
Classes Output
ClassesStream Reader
Classes Writer
Classes
Classes Classes Classes Classes

Memory File Pipe Memory File Pipe

Memory File Pipe 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.
Copyright © 2009 by Royal Institute of Information Technology

Hierarchy of input stream classes

File
File

InputStream
InputStream

FileInputStream SequenceInputStream
FileInputStream SequenceInputStream

PipeInputStream ObjectInputStream
PipeInputStream ObjectInputStream

ByteArrayInputStream StringBufferInputStream
FilterInputStream
FilterInputStream

DataInputStream
DataInputStream

DataInput
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() ▫ readDouble()
▫ readInt() ▫ readLine()
▫ readLong() ▫ readChar()
▫ readFloat() ▫ readBoolean()
▫ readUTF()
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.
Copyright © 2009 by Royal Institute of Information Technology

Hierarchy of output stream classes

Object
Object

OutputStream
OutputStream

FileOutputStream ObjectOutputStream
FileOutputStream ObjectOutputStream

PipedOutputStream ByteArrayOutputStream

FilterOutputStream
FilterOutputStream

BufferedOutputStream PushbackOutputStream
DataOutputStream
DataOutputStream

DataOutput
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() ▫ writeDouble()
▫ writeInt() ▫ writeBytes()
▫ writeLong() ▫ writeChar()
▫ writeFloat() ▫ writeBoolean()
▫ writeUTF()
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
Copyright © 2009 by Royal Institute of Information Technology

Hierarchy of reader stream classes

Object
Object

Reader
Reader

BufferedReader StringReader
BufferedReader StringReader

CharArrayReader PipeReader
PipeReader

InputStreamReader FilterReader
FilterReader

FileReader PushbackReader
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.
Copyright © 2009 by Royal Institute of Information Technology

Hierarchy of writer stream classes

Object
Object

Writer
Writer

BufferedWriter PrintWriter
BufferedWriter PrintWriter

CharArrayWriter StringWriter
CharArrayWriter StringWriter

FilterWriter PipeWriter
FilterWriter PipeWriter
OutputStreamWriter
OutputStreamWriter

FileWriter
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
Object
Interface Interface
Interface Interface

DataInput DataOutput
DataInput DataOutput

RandomAccessFile
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
▫ Getting the name of a file
▫ Getting the size of a file
▫ Checking the existence of a file
▫ Renaming a file
▫ Checking whether the file is writable
▫ Checking whether the file is readable
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
InterruptedIOExceptio Warns that an I/O operations has been
n 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”
fis “test.dat”
Stream object Filename
Stream object Filename

fis inFile “test.dat”

fis inFile “test.dat”
Stream object File object Filename
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);
}
}
catch(IOException e){
System.out.println(e);
System.exit(-1);
}
finally{
try{
ins.close();
outs.close();
}
catch(IOException e) { }
}
}
}
Reading from and Writing to files

ins stream
ins stream
input.dat
input.dat
read()
inFile read()
inFile

Program
Program

output.dat write()
output.dat write()

outFile outs stream

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);
}
}
}
Copyright © 2009 by Royal Institute of Information Technology

Reading Bytes from a file

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);
}
}
}
Copyright © 2009 by Royal Institute of Information Technology

Copying bytes from one file to 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”);
do{
byteRead = (byte) infile.read();
outfile.write(byteRead);
}
while (byteRead != -1);
}
(Continued)
Copyright © 2009 by Royal Institute of Information Technology

Program Continued
catch(FileNotFoundException e){
System.out.println(“File not Found”);
}
catch(IOException e){
System.out.println(e.getMessage());
}
finally{
try{
infile.close();
outfile.close();
}
catch(IOException e){ }
}
}
}
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
DataInput

DataInputStream
Interface Class

DataOutput FilterOutputStream
DataOutput

DataOutputStream
Copyright © 2009 by Royal Institute of Information Technology

Reading and Writing primitive 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();
}
}
Copyright © 2009 by Royal Institute of Information Technology

Using a Single file for storing and retrieving

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 FileOutputStream(inFile));
for(int i = 0; i<20; i++)
dos.writeInt((int) (math.random() *100));
}
(Continued)
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
BufferedOutputStream classes.
Copyright © 2009 by Royal Institute of Information Technology

IIIustration of concatenation and

Buffering
file 1 inBuffer
file 1
file1 + file2
file1 + file2
file 2 read()
file 2 file3

Program

outBuffer write()

Screen
Screen
System.out
Copyright © 2009 by Royal Institute of Information Technology

Program of Concatenation and 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”);
//Concatenate file1 and file2 into file3
file3 = new SequenceInputStream (file1, file2);
(Continued)
Copyright © 2009 by Royal Institute of Information Technology

Program (Continued)
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();
file1.close();
file2.close();
}
}
Copyright © 2009 by Royal Institute of Information Technology

Random Access Files

• 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.
Copyright © 2009 by Royal Institute of Information Technology

Reading/Writing using a random access file

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());
System.out.println(file.readInt());
System.out.println(file.readDouble());

(Continued)
Copyright © 2009 by Royal Institute of Information Technology

Program (Continued)
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){
System.out.println(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();
}
catch(IOException ioe){
System.out.println(ioe);
}
}
}
Copyright © 2009 by Royal Institute of Information Technology

Interactive input and output

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]

Item cost : 452.0
Total Items : 193
Total Cost : 87236.0
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

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
Filter 1 Filter 2 Filter 3