Files and Streams

1
Files and Streams
2
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

3
Review

• The following two statements will associate file
  1 and file 2 to the same file
• File file1new File(c\\one\\two,three.dat)
• File file2 new File(c\\one\\two\\three.dat)
• True
• False

4
Review

• The following two statements will associate file
  1 and file 2 to the same file
• File file1new File(c\\one\\two,three.dat)
• File file2 new File(c\\one\\two\\three.dat)
• True
• False

5
Review

• The following two statements will associate file
  1 and file 2 to the same file
• File file1new File(c\\one\\two,three.dat)
• File file2 new File(c\\one\\two\\three.dat)
• True
• False

6
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
• File( \\ \\ )
• P
• mydata.dat
• File
• Program
• New
• File

7
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
• File( \\ \\ )
• P
• mydata.dat
• file
• Programs
• new
• File

F
C
E
A
D
B
8
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

9
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

10
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

11
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

12
Files and Streams

• java.io classes
• FileInputStream and FileOutputStream byte-based
  I/O
• FileReader and FileWriter character-based 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

13
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)

14
Javas view of a file of n bytes.
15
Overview of old knowledge of File I/O
Low level I/O
High level I/O
Text file I/O
Treat a file As a set of bytes
Treat A file As a set of data of primitive Data
type
Treat A file As a set of text (or String)
16
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.

17
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.

18
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
19
Sample Low-Level File Input
20
Low level data output
Step 1 Create a File object Step 2 Create a
FileOutputStream object Step 3Get data
ready Step 4Write data to output stream Step 5
Close the file
21
Sample Low-Level File Output
22
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

23
Setting up DataOutputStream

• A standard sequence to set up a DataOutputStream
  object

24
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(987654
321) outDataStream.writeLong(11111111L) outDat
aStream.writeFloat(22222222F) outDataStream.writ
eDouble(3333333D) outDataStream.writeChar('A')
outDataStream.writeBoolean(true) //output
done, so close the stream outDataStream.close()

25
Setting up DataInputStream

• A standard sequence to set up a DataInputStream
  object

26
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(in
DataStream.readInt()) System.out.println(inD
ataStream.readLong()) System.out.println(inD
ataStream.readFloat()) System.out.println(in
DataStream.readDouble()) System.out.println(
inDataStream.readChar()) System.out.println(
inDataStream.readBoolean()) //input done,
so close the stream inDataStream.close()

27
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.

28
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

29
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

30
Create FileReader and BufferedReader objects

• How to create a FileReader ojbect
• FileReader ltvariable_namegt new
  FileReader(ltname of a File ojbectgt)
• How to create a BufferedReader object
• BufferedReader ltvariable_namegt new
  BufferedReader(ltname of a FileReader object)
• How to read a line
• ltbufferedReader object namegt.readLine()

31
Write data to a text file

• Step 1 Create a File object
• Step 2 Create a FileOutputStream object
• Step 3 Create a PrinterWriter object
• Step 4 Write line(s)
• Step 5 Close the file

32
Create a FileOutputSTream and PrintWriter objects

• How to create a FileOutputStream objects
• FileOutputStream ltvariable_namegt new
  FileOutputStream(ltname of a File objectgt)
• How to create a PrintWriter object
• PrintWriter ltvariable_namegt new
• PrintWriter(ltname of a FileOutputStream
  objectgt)
• How to write a string to a file
• ltA print writer objectgt.println(ltstring object
  namegt)
• More details on this link

33
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 int10
• for (int i0iltnumber.length i)
• numberi i1
• printWriter.println(numberi)
• printWriter.close()
• System.exit(0)

34
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 int10
• for (int i0iltnumber.length i)
• numberi i1
• printWriter.println(numberi)
• printWriter.close()
• System.exit(0)

Step 1-3
35
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 int10
• for (int i0iltnumber.length i)
• numberi i1
• printWriter.println(numberi)
• printWriter.close()
• System.exit(0)

Step 4 (in for loop)
36
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 int10
• for (int i0iltnumber.length i)
• numberi i1
• printWriter.println(numberi)
• printWriter.close()
• System.exit(0)

Step 5 (close file)
37
File Input and Output
Sequential-access files
Random-access files
38
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

39
Create a text file using Formatter class

• Step 1Pass 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)

40
Practice

• Step 1 Create a package called Lab7 under your
  Labs project. Select Lab7 package -gt New class -gt
  AccountRecord. Then cut and paste the content of
  AccountRecord.java in D2L to this AccountRecord
  class.
• Step 2 Select Lab7 package -gt New class -gt
  CreateTextFile. Then cut and paste the content of
  CreateTextFile class in D2L to this newly created
  class.
• Step 3. Select Lab7 package -gt New class -gt
  CreateTextFileMain class.

41
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.

42
End-of-file key combinations for various popular
operating systems.
43
Reading Data from a Sequential-Access 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

44
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 -gt New class -gt
  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.

45
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.

46
Practice Exercise for Midterm exam
47
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

48
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

49
Javas view of a random-access file.
50
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

51
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). File-open mode specified as
  second argument to RandomAccessFile constructor

52
Practice

• Step 1 Create a package called Lab7 under your
  Labs project. Select Lab7 package -gt New class -gt
  RandomAccessAccountRecord. Then cut and paste the
  content of RandomAccessAccountRecord.java in D2L
  to this class.
• Step 2 Select Lab7 package -gt New class -gt
  CreateRandomFile. Then cut and paste the content
  of CreateRandomFile class in D2L to this newly
  created class.
• Step 3. Select Lab7 package -gt New class -gt
  CreateRandomFileMain class.

53
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.

54
Writing Data Randomly to a Random-Access 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

55
Writing Data Randomly to a Random-Access File

• Once location known, new record data can be
  written without worrying about rest of file, as
  each record is always same size

56
Practice

• Step 1 Select Lab7 package -gt New class -gt
  WriteRandomFile. Then cut and paste the content
  of WriteRandomFile class in D2L to this newly
  created class.
• Step 3. Select Lab7 package -gt New class -gt
  WriteRandomFileMain class in which we
• - create a WriteRandomFile object
• - using this object to open file, add records
  and write to a random-access file.

57
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

58
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
  records data can only be placed in specific
  portion of file
• Sorting with direct-access techniques is
  blazingly fastspeed achieved by making file
  large enough to hold every possible record
• Space/time trade-off