File Input

and Output
Objectives
After you have read and studied this chapter, you
should be able to

• Use File object to get info about a file

• Include a JFileChooser object in your program to let the user

specify a file.

• Write bytes to a file and read them back from the file, using
FileOutputStream and FileInputStream.

• Write values of primitive data types to a file and read them

back from the file, using DataOutputStream and
DataInputStream.

• Write text data to a file and read them back from the file, using
FileWriter,PrintWriter and FileReader,BufferedReader

• Read a text file using Scanner

what is a file?
a collection of bytes
Computer makes no distinction between eg. image files and text
files. Its all bytes (binary) to the hardware. What those bytes are
used for is up to the software.

All information in any file is kept in binary form.

Where bytes can be read from

and written to
Bytes read from file delivered to program
Bytes written to file from program
file types
A text file (ASCII file)
contains bytes that represent (in ASCII):
'A' through 'Z'
'a' through 'z'
'0' through '9'
space character
punctuation and symbols
control characters - eol, tabs etc.

A binary file
contains bytes that represent other format (eg.
numbers, image, audio, formatted text etc)
java file class
File class in java is from java.io
• To use, we must first create a file object
• A file object can represent a file or a directory

Creates File object for the file

File inFile = new File(“sample.dat”); sample.dat in the current
directory

Creates File object for test.dat in

File inFile = new File directory C:\SamplePrograms
using file separator /
(“C:/SamplePrograms/test.dat”); and full pathname.
some file methods
if ( inFile.exists() ) To see if inFile is
associated to a real file
correctly.

if ( inFile.isFile() ) To check inFile is a

file or directory.
if ( inFile.isDirectory() ) Can also test directly
if is directory

File directory = new

File("C:/JavaPrograms/Ch12");
List the name of all files
String filename[] = directory.list(); in the directory
C:\JavaProjects\Ch12
for (int i = 0; i < filename.length; i++) {
System.out.println(filename[i]);
}
 To see the size of the file
if ( inFile.length( ) ) { in bytes represented by
inFile

if ( inFile.getName() ) { To get the name of the file

represented by inFile

if ( inFile.canRead() ) { To see if inFile is

associated to a file that
exist & can be read

if ( inFile.canWrite() ) { To see if inFile is

associated to a file that
exist & can be written
file GUI JFileChooser class

A javax.swing.JFileChooser object allows the user to select a file.

JFileChooser chooser = new JFileChooser();

chooser.showOpenDialog(null);

JFileChooser chooser =
To start the
new JFileChooser("D:/JavaPrograms/Ch12"); listing from a
specific
directory
chooser.showOpenDialog(null);
using JFileChooser

int status = chooser.showOpenDialog(null);

if (status == JFileChooser.APPROVE_OPTION) {
JOptionPane.showMessageDialog(null, "Open is clicked");

} else { //== JFileChooser.CANCEL_OPTION

JOptionPane.showMessageDialog(null, "Cancel is clicked");
}

File selectedFile = chooser.getSelectedFile();

File currentDirectory = chooser.getCurrentDirectory();

reading / writing to file
To read or write data to file
create Java stream objects and attach it to the file.

Java i/o stream

A stream is a sequence of data items, usually 8-bit bytes.
input stream – source where data come
output stream – destination where data goes to
Types of i/o stream
• character-oriented (for text files)
• byte-oriented (binary files)

IO class
Hierarchy
in java.io
package

FileOutputStream FileInputStream
for output a allows us to
sequence of bytes ( read in an
data of type byte) array of bytes.
sample: byte-level binary file output

//set up file and stream

File outFile = new File("sample1.data");

FileOutputStream
outStream = new FileOutputStream( outFile );

//data to save
byte[] byteArray = {10, 20, 30, 40,
50, 60, 70, 80};

//write data to the stream

outStream.write( byteArray );

//output done, so close the stream

outStream.close();
sample: byte-level binary file input

//set up file and stream

File inFile = new File("sample1.data");
FileInputStream inStream = new FileInputStream(inFile);

//set up an array to read data in

int fileSize = (int)inFile.length();
byte[] byteArray = new byte[fileSize];

//read data in and display them

inStream.read(byteArray);
for (int i = 0; i < fileSize; i++) {
System.out.println(byteArray[i]);
}

//input done, so close the stream

inStream.close();
other java I/O streams

• FileOutputStream and DataOutputStream are used to

output primitive data values from /to stream (network or
file). FileInputStream and DataInputStream is used for
input
• To read the data back correctly, we must know the
order of the data stored and their data types
using DataOutputStream
A standard sequence for DataOutputStream object:
 Sample Output

import java.io.*;
class Ch12TestDataOutputStream {
public static void main (String[] args) throws IOException {

. . . //set up outDataStream

//write values of primitive data types to the stream

outDataStream.writeInt(987654321);
outDataStream.writeLong(11111111L);
outDataStream.writeFloat(22222222F);
outDataStream.writeDouble(3333333D);
outDataStream.writeChar('A');
outDataStream.writeBoolean(true);

//output done, so close the stream

outDataStream.close();
}
}
Using DataInputStream
A standard sequence to set up a DataInputStream object:
Sample Input

import java.io.*;
class Ch12TestDataInputStream {
public static void main (String[] args) throws IOException {

. . . //set up inDataStream

//read values back from the stream and display them

System.out.println(inDataStream.readInt());
System.out.println(inDataStream.readLong());
System.out.println(inDataStream.readFloat());
System.out.println(inDataStream.readDouble());
System.out.println(inDataStream.readChar());
System.out.println(inDataStream.readBoolean());

//input done, so close the stream

inDataStream.close();
}
}
reading data back in right order
The order of write and read operations must match in
order to read the stored primitive data back correctly .
reading & writing textfile
• Instead of storing primitive data values as binary data in a file, we can
convert and store them as a string data.
• This allows us to view the file content using any text editor
• To write data as a string to text file, use a FileWriter and PrintWriter
object
• To read data from textfile, use FileReader and BufferedReader classes
• From Java 5.0 (SDK 1.5), we can also use the Scanner class for reading
textfiles
sample writing to textfile
import java.io.*;
class Ch12TestPrintWriter {
public static void main (String[] args) throws IOException {

//set up file and stream

File outFile = new File("sample3.data");
FileWriter outFileStream
= new FileWriter(outFile);
PrintWriter outStream = new PrintWriter(outFileStream);

//write values of primitive data types to the stream

outStream.println(987654321);
outStream.println("Hello, world.");
outStream.println(true);

//output done, so close the stream

outStream.close();
}
}
sample reading from textfile
import java.io.*;
class Ch12TestBufferedReader {

public static void main (String[] args) throws IOException {

//set up file and stream

File inFile = new File("sample3.data");
FileReader fileReader = new FileReader(inFile);
BufferedReader bufReader = new BufferedReader(fileReader);
String str;

str = bufReader.readLine();
int i = Integer.parseInt(str);

//similar process for other data types

bufReader.close();
}
}
sample reading textfile using scanner
import java.io.*;

class Ch12TestScanner {

public static void main (String[] args) throws IOException {

//open the Scanner

File inFile = new File("sample3.data");
Scanner scanner = new Scanner(inFile);

//get integer
int i = scanner.nextInt();

//similar process for other data types

scanner.close();
}
}
sample reading textfile using scanner
Code fragments shows how to read the whole contents of a file

Use hasNextLine() & nextLine() methods

try{
// read line one by one till all line is read.
Scanner scanner = new Scanner(inFile);
while (scanner.hasNextLine()) { //check if there are more line
String line = scanner.nextLine();
System.out.println(line);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}