Download MCS220Week7_new

Files and Streams
Midterm exam



Time: Wednesday, October 31, 2007
Format:
• Multiple choices (about 15 to 20 questions)
• Determine the results of the code
• Writing a piece of code
Cover: Fundamental of Java, Array,
Search and Sort, String, Error handling
Introduction
Why is File I/O important?



Storage of data in variables and arrays is
temporary
Files used for long-term retention of
large amounts of data, even after the
programs that created the data terminate
Persistent data – exists beyond the
duration of program execution
Review
The following two statements will associate
file 1 and file 2 to the same file:
File file1=new File(“c:\\one\\two”,”three.dat”);
File file2 = new File(“c:\\one\\two\\three.dat”);
a.
b.
True
False
Review
The following two statements will associate
file 1 and file 2 to the same file:
File file1=new File(“c:\\one\\two”,”three.dat”);
File file2 = new File(c:\\one\\two\\three.dat”);
a.
b.
True
False
Review
The following two statements will associate
file 1 and file 2 to the same file:
File file1=new File(“c:\\one\\two”,”three.dat”);
File file2 = new File(c:\\one\\two\\three.dat”);
a.
b.
True
False
Review
Complete a code fragment that will create a File object and
associate it to an existing file named mydata.dat in the
Programs directory of a windows network P: drive
=
a.
b.
c.
d.
e.
f.
P:
mydata.dat
file
Programs
new
File
File(“
\\
\\
“);
Review
Complete a code fragment that will create a File object and
associate it to an existing file named mydata.dat in the
Programs directory of a windows network P: drive
F
a.
b.
c.
d.
e.
f.
C
P:
mydata.dat
file
Programs
new
File
=
E
File(“
A
\\
D
\\
B
“);
Java and File Input/Output



Files stored on secondary storage
devices
Stream – ordered data that is read from
or written to a file
Java views each files as a sequential
stream of bytes
Files and Streams

Operating system provides mechanism
to determine end of file
• End-of-file marker
• Count of total bytes in file
• Java program processing a stream of bytes
receives an indication from the operating
system when program reaches end of stream
Files and Streams

File streams
• Byte-based streams – stores data in binary format
• Binary files – created from byte-based
•
streams, read by a program that converts data
to human-readable format
Character-based streams – stores data as a
sequence of characters
• Text files – created from character-based
streams, can be read by text editors
Files and Streams


Java opens file by creating an object and
associating a stream with it
Standard streams:
•System.in – standard input stream object
•System.out – standard output stream object,
•System.err – standard error stream object
Files and Streams

java.io classes
•FileInputStream and
FileOutputStream – byte-based I/O
•FileReader and FileWriter – characterbased I/O
•ObjectInputStream and
ObjectOutputStream – used for input and
output of objects or variables of primitive data
types
•File – useful for obtaining information about
files and directories
Files and Streams

Classes Scanner and Formatter
•Scanner – can be used to easily read data
from a file
•Formatter – can be used to easily write
data to a file (needs j2se 5.0 to run)
Java’s view of a file of n
bytes.
Overview of old knowledge of
File I/O
Low level I/O
Treat a file
As a set of bytes
High level I/O
Text file I/O
Treat
A file As a set of data of
primitive
Data type
Treat
A file As a set of text
(or String)
Low-Level File I/O




To read data from or write data to a file, we must create
one of the Java stream objects and attach it to the file.
A stream is a sequence of data items, usually 8-bit bytes.
Java has two types of streams: an input stream and an
output stream.
An input stream has a source form which the data items
come, and an output stream has a destination to which
the data items are going.
Streams for Low-Level File I/O



FileOutputStream and FileInputStream are
two stream objects that facilitate file access.
FileOutputStream allows us to output a
sequence of bytes; values of data type byte.
FileInputStream allows us to read in an
array of bytes.
Low level data input
Step 1: Create a File object
Step 2: Create a FileInputStream object
Step 3: Declare an array to keep input
data, allocate memory for this array
Step 4: Read data and process data if
needed
Step 5: Close the file
Sample: Low-Level 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();
Low level data output
Step 1: Create a File object
Step 2: Create a FileOutputStream object
Step 3:Get data ready
Step 4:Write data to output stream
Step 5: Close the file
Sample: Low-Level 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();
Streams for High-Level File I/O



FileOutputStream and DataOutputStream are
used to output primitive data values
FileInputStream and DataInputStream are
used to input primitive data values
To read the data back correctly, we must know
the order of the data stored and their data
types
Setting up DataOutputStream

A standard sequence to set up a 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();
}
}
Setting up 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.
Textfile Input and Output



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 output data as a string to file, we use a PrintWriter
object
To input data from a textfile, we use FileReader and
BufferedReader classes
• From Java 5.0 (SDK 1.5), we can also use the
Scanner class for inputting text files
Read data from a text file
Step 1: Create a File object
Step 2: Create a FileReader object
Step 3: Create a BufferedReader object
Step 4: Read line by line
Step 5: Convert String object to primitive data
type as necessary
Step 6: Close the file
Create FileReader and
BufferedReader objects
How to create a FileReader ojbect:
FileReader <variable_name> = new
FileReader(<name of a File ojbect>);
How to create a BufferedReader
object:
BufferedReader <variable_name> = new
BufferedReader(<name of a FileReader
object);
How to read a line
<bufferedReader object name>.readLine();
Write data to a text file
Step 1: Create a File object
Step 2: Create a FileOutputStream object
Step 3: Create a PrintWriter object
Step 4: Write line(s)
Step 5: Close the file
Create a FileOutputSTream and
PrintWriter objects

How to create a FileOutputStream objects:
FileOutputStream <variable_name> = new
FileOutputStream(<name of a File object>);

How to create a PrintWriter object
PrintWriter <variable_name> = new
PrintWriter(<name of a FileOutputStream object>);
 How to write a string to a file
<A print writer object>.println(<string object name>);
More details on this link
Example
import java.io.*;
public class OutputExample{
public static void main (String[] args) throws IOException {
File inFile = new File("e:\\Temp\\output.dat");
FileOutputStream fileStream = new FileOutputStream(inFile);
PrintWriter printWriter = new PrintWriter(fileStream);
String inputStr;
int number[] = new int[10];
for (int i=0;i<number.length; i++) {
number[i] = i+1;
printWriter.println(number[i]);
}
printWriter.close();
System.exit(0);
}
}
Example
import java.io.*;
public class OutputExample{
public static void main (String[] args) throws IOException {
File inFile = new File("e:\\Temp\\output.dat");
FileOutputStream fileStream = new FileOutputStream(inFile);
PrintWriter printWriter = new PrintWriter(fileStream);
String inputStr;
int number[] = new int[10];
for (int i=0;i<number.length; i++) {
number[i] = i+1;
printWriter.println(number[i]);
}
printWriter.close();
System.exit(0);
}
}
Step 1-3
Example
import java.io.*;
public class OutputExample{
public static void main (String[] args) throws IOException {
File inFile = new File("e:\\Temp\\output.dat");
FileOutputStream fileStream = new FileOutputStream(inFile);
Step 4
PrintWriter printWriter = new PrintWriter(fileStream);
String inputStr;
(in for loop)
int number[] = new int[10];
for (int i=0;i<number.length; i++) {
number[i] = i+1;
printWriter.println(number[i]);
}
printWriter.close();
System.exit(0);
}
}
Example
import java.io.*;
public class OutputExample{
public static void main (String[] args) throws IOException {
File inFile = new File("e:\\Temp\\output.dat");
FileOutputStream fileStream = new FileOutputStream(inFile);
Step 5
PrintWriter printWriter = new PrintWriter(fileStream);
String inputStr;
(close file)
int number[] = new int[10];
for (int i=0;i<number.length; i++) {
number[i] = i+1;
printWriter.println(number[i]);
}
printWriter.close();
System.exit(0);
}
}
File Input and Output
Sequential-access
files
Random-access
files
Sequential-Access Text Files




Each line describes a record in a
database. Records are stored in order by
record-key field
Can be created as text files or binary
files
Input files: Programmer must structure files
Output files: Formatter class can be used to
open a text file for writing
Create a text file using
Formatter class
Step 1:Pass name of file to constructor
•
•
If file does not exist, will be created
If file already exists, contents are truncated (discarded)
Step 2:
•
Use method format to write formatted text to file
Step 3:
•
Use method close to close the Formatter object (if
method not called, OS normally closes file when program
exits)
Practice
Step 1: Create a package called Lab7 under your Labs
project. Select Lab7 package -> New class ->
AccountRecord. Then cut and paste the content of
AccountRecord.java in D2L to this AccountRecord class.
Step 2: Select Lab7 package -> New class ->
CreateTextFile. Then cut and paste the content of
CreateTextFile class in D2L to this newly created class.
Step 3. Select Lab7 package -> New class ->
CreateTextFileMain class.
Practice
Step 4: In CreateTextFileMain class, add
the main method, in which you should:
- create a CreateTextFile object
- using this object to open a file, add
records and write to a file.
End-of-file key combinations
for various popular operating
systems.
Operating system
Key combination
UNIX/Linux/Mac OS X
<return> <ctrl> d
Windows
<ctrl> z
Reading Data from a SequentialAccess Text File


Data is stored in files so that it may be
retrieved for processing when needed
Scanner object can be used to read
data sequentially from a text file
• Pass File object representing file to be read to Scanner
constructor
• FileNotFoundException occurs if file cannot be found
• Data read from file using same methods as for keyboard
input – nextInt, nextDouble, next, etc.
• IllegalStateException occurs if attempt is made to
read from closed Scanner object
Practice
Step 1: Under your Lab7 package, create a new
class ReadTextFile. Then cut and paste the
content of ReadTextFile.java in D2L to this
class.
Step 2: Select Lab7 package -> New class ->
ReadTextFileMain class. In this class, you
should create a ReadTextFile object
- using this object to open a file, read records
from a text file and close that file.
Updating Sequential-Access Files



Data in many sequential files cannot be
modified without risk of destroying other
data in file
Old data cannot be overwritten if new
data is not same size
Records in sequential-access files are
not usually updated in place. Instead,
entire file is usually rewritten.
Practice Exercise for Midterm
exam
Random-Access Files



Sequential-access files inappropriate for
instant-access applications
Instant-access applications are applications in
which desired information must be located
immediately
Instant access possible with random-access
files (also called direct-access files) and
databases
Random-Access Files


Data can be inserted in random-access
file without destroying other data
Different techniques for creating
random-access files
• Simplest: Require that all records in file be
same fixed length
• Easy to calculate (as a function of record size
and record key) exact location of any record
relative to beginning of file
Java’s view of a randomaccess file.
Creating a Random-Access File

RandomAccessFile class
•
•
•
Includes all capabilities of FileInputStream and
FileOutputStream
Includes capabilities for reading and writing primitive-type
values, byte arrays and strings
Using RandomAccessFile, program can read or write data
beginning at location specified by file-position pointer
Creating a Random-Access File

RandomAccessFile class
•
•
•
•
Manipulates all data as primitive types
Methods readInt, readDouble, readChar used to read
integer, double and character data from file
Methods writeInt, writeDouble, writeChars used to
write integer, double and string data to file
File-open mode – specifies whether file is opened for
reading (“r”), or for both reading and writing (“rw”). Fileopen mode specified as second argument to
RandomAccessFile constructor
Practice
Step 1: Create a package called Lab7 under your Labs
project. Select Lab7 package -> New class ->
RandomAccessAccountRecord. Then cut and paste the
content of RandomAccessAccountRecord.java in D2L to
this class.
Step 2: Select Lab7 package -> New class ->
CreateRandomFile. Then cut and paste the content of
CreateRandomFile class in D2L to this newly created
class.
Step 3. Select Lab7 package -> New class ->
CreateRandomFileMain class.
Practice
Step 4: In CreateRandomFileMain class,
add the main method, in which you
should:
- create a CreateRandomFile object
- using this object to create a file.
Writing Data Randomly to a RandomAccess File


RandomAccessFile method seek
positions file-position pointer to a specific
location in a file relative to beginning of
file
Size of each record is known, so location
in file of a specific record can be found
by multiplying size of record with number
of record
Writing Data Randomly to a RandomAccess File

Once location known, new record data
can be written without worrying about
rest of file, as each record is always
same size
Practice
Step 1: Select Lab7 package -> New class ->
WriteRandomFile. Then cut and paste the
content of WriteRandomFile class in D2L to
this newly created class.
Step 3. Select Lab7 package -> New class ->
WriteRandomFileMain class in which we
- create a WriteRandomFile object
- using this object to open file, add records and
write to a random-access file.
Reading Data Sequentially from
a Random-Access File


Open file with “r” file-open mode for reading
Ignore empty records (usually those with
account number of zero) when reading from
file
Reading Data Sequentially from
a Random-Access File


Records stored by account number in
random-access files have added bonus of
being sorted, as each record’s data can only
be placed in specific portion of file
Sorting with direct-access techniques is
blazingly fast—speed achieved by making
file large enough to hold every possible
record
• Space/time trade-off