File Input and Output

1
Chapter 12

• File Input and Output

2
Topics

• Stream Classes
• Files
• Text Input and Output
• JFileChooser for GUI programs
• Binary files

3
Files

• Program data that is stored in variables ceases
  to exist when the program terminates.
• Files provide a way of storing data after the
  program terminates.
• There are two basic ways to store data in files
• text data is human readable, system independent
• binary data has the same format as it would in
  memory

4
File I/O

• Once a file is opened by associating a File
  object to it, we can access the data in the file.
• 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.

5
Streams

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

6
FileStreams

• FileOutputStream and FileInputStream are two
  stream objects that facilitate file access.
• FileReader and FileWriter are used for input and
  output of text data
• FileOutputStream allows us to output a sequence
  of bytes values of data type byte.

7
File Input and Output

• The action of saving, or writing, data to a file
  is called file output.
• The action of reading data from a file is called
  file input.
• To work with files, we need to make an
  association between an object in the program and
  a file on the disk.
• When a valid association is established, we say a
  file is opened.
• A file must be opened before we can do any input
  and output to the file.

8
Text Files

• Data stored as text is easy for humans to deal
  with.
• All data is converted to string data.
• A file whose contents are stored in ASCII format
  is called a text file.
• A text file is what you create with vi.
• Text data is what we get from the keyboard and
  send to the console.

9
I/O Classes

• Keyboard input and console output

10
Input Files

• Several ways to create a FileInputStream
• Give the constructor the name of the file
• FileInputStream fin
• new FileInputStream(sample.data)
• Create the FileInputStream and then open it
• FileInputStream fin new FileInputStream()
• fin.open( sample.data)
• From the FileInputStream, we can create an
  InputStreamReader and BufferedReader just as we
  did for System.in

11
Text Input

• To read data from a text file, we use the
  FileReader and BufferedReader objects.
• We first associate a BufferedReader object to a
  file.
• Then we read data, using the readLine method of
  BufferedReader.
• Finally, we convert the String to a primitive
  data type as necessary.
• This is the same process we used for reading from
  the keyboard

12
FileReader Class

• We can use the FileReader class to reduce the
  number of steps needed to create a BufferedReader
• FileReader fin
• new FileReader("file.dat")
• BufferedReader in
• new BufferedReader( fin)

13
Text Output

• PrintWriter is an object we use to generate a
  textfile.
• PrintWriter supports only two output methods
• print
• println (for print line)
• An argument to the methods may be any primitive
  data type.
• The methods convert the parameter to string and
  output this string value.
• These should look familiar - System.out is a
  PrintWriter

14
PrintWriter Objects

• The constructor of PrintWriter requires a Writer
  object as its argument.
• FileWriter new
• FileWriter( "test.dat")
• PrintWriter out
• new PrintWriter( fout)

15
IOExceptions for File I/O

• The methods that link a file to a Stream or
  Reader or Writer will all throw an IOException if
  they fail.
• For reading, failure means the file wasn't found
• For writing, you would get an error if a
  write-protected file of the same name exists.

16
File Objects

• An alternate approach to what we've seen so far
  is to use the File class
• Create a File object and associate it with the
  file from which we wish to read.
• File inFile new File(sample.data)
• Associate it with a FileStream of the appropriate
  kind.
• FileInputStream fin
• new FileInputStream( inFile)

17
Testing for File Success

• We can check if a File object is associated
  correctly to an existing file by calling its
  exists method
• if (inFile.exists())
• //inFile is associated correctly to
• //an existing file
• else
• //inFile is not associated to any //existing
  file

18
Working With Directories

• A File object may also be associated to a
  directory.
• File directory
• new File (C/JavaPrograms/Ch12)
• String filename directory.list()
• for (int i0 iltfilename.length i)
• System.out.println(filenamei)
• To determine if a File object is associated to a
  file or directory, we call its boolean method
  isFile

19
Paths for Input Files

• The code on the previous slide assumes that the
  file is located in the current directory.
• Otherwise, we must specify the path and file name
  when we call the constructor
• File inFile
• new File(C/JavaPrograms,xyz.data)
• The formatting of the path name and file name is
  different for different operating systems.

20
JFileChooser Objects

• For GUI programs, there is a Component that
  allows you to browse for files.
• A javax.swing.JFileChooser object allows the user
  to select a file.
• The showOpenDialog method displays a JFileChooser
  with an Open button.
• JFileChooser chooser new JFileChooser()
• ...
• chooser.showOpenDialog(null)
• The showSaveDialog method displays a JFileChooser
  with a Save button.

21
JFileChooser Methodss

• The getSelectedFile method retrieves the desired
  file.
• The getName and getAbsolutePath methods retrieve
  the name and full path of a selected file.

22
File Filters

• A file filter may be used to remove unwanted
  files from the list.
• Define a subclass of the javax.swing.filechooser.F
  ileFilter class and provide the accept and
  getDescription methods.
• public boolean accept(File file)
• public String getDescription( )
• The accept method returns true if the parameter
  file is a file to be included in the list.
• The getDescription method returns a text that
  will be displayed as one of the entries for the
  Files of Type drop-down list.

23
FileFilter and JFileChooser Objects

• When the filter class is defined, we can assign
  it to a file chooser to restrict the listing to
  the desired directories and files.
• JFileChooser chooser
• new JFileChooser()
• chooser.setFileFilter(new JavaFilter(())
• int status
• chooser.showOpenDialog(null)

24
Low-Level I/O

• Sometimes, it is convenient to work directly with
  bytes.
• In this case, you just create a Stream and use
  the read method to read one or more bytes at a
  time.
• Similarly, you can use StreamReaders and
  StreamWriters to work with text one character at
  a time.

25
Byte I/O

• We will process the following byte array
• byte byteArray 10, 20, 30, 40, 50, 60, 70,
  80
• We create a File object
• File outFile new File (sample1.data)
• Associate a new FileOutputStream object to
  outFile
• FileOutputStream outStream
• new FileOutputStream(outFile)
• Write the whole byte array at once to the file
• outstream.write(byteArray)
• After the values are written to the file, we must
  close the stream
• outStream.close()
• If the stream object is not closed, then data may
  get lost due to data caching.

26
Data Caching

• Data is saved in blocks of bytes to reduce the
  time it takes to save all of our data.
• The operation of saving data as a block is called
  data caching.
• To carry out data caching, part of memory is
  reserved as a data buffer or cache, which is used
  as a temporary holding place.
• Data are first written to a buffer. When the
  buffer becomes full, the data in the buffer are
  actually written to a file.
• If there are any remaining data in the buffer and
  the file is not closed, those data will be lost.

27
Byte Input

• To read data into a program, we reverse the steps
  in the output routine.
• First we create a FileInputStream object
• File inFile new File(sample1.data)
• FileInputStream inStream new FileInputStream(in
  File)
• Next declare and create byteArray
• int filesize (int) inFile.length()
• byte byteArray new bytefilesize

28
Byte Input

• We can use the length method of the File class to
  determine the size of the file.
• This allows us to create an array of bytes whose
  size is the size of the file.
• Finally, we read the data into an array of bytes
  using the read method of FileInputStream
• inStream.read(byteArray)

29
Using other Types of Data

• We can output other types of data if we can type
  cast them into bytes.
• To read the data back, we use the read method.
• Depending on the data type we converted the data
  from, we may need to type cast back into the
  original data type.

30
Binary Files

• Text files are not the most efficient way to
  store data.
• Storing data in binary format (the format used in
  memory) takes less space.
• Binary files are useful for data that olnly needs
  to be read by another program.

31
Classes for Binary Files
32
DataOutputStreams

• Using DataOutputStream allows us to output Java
  primitive data type values.
• A DataOutputStream object will convert the
  primitive data type values into a sequence of
  bytes.
• The argument to the DataOutputStream constructor
  is a FileOutputStream object.
• A DataOutputStream object does not get connected
  to a file directly.
• The role of a DataOutputStream object is to
  provide high-level access to a file by handling
  the data type conversions.

33
DataInputStreams

• To read data back from the file, we reverse the
  operation.
• We use three objects File, FileInputStream, and
  DataInputStream.
• Data must be read in the order in which it was
  written otherwise, the results will be
  unpredictable.

34
Binary Output

• FileOutputStream and DataOutputStream objects
  produce a binary file in which the contents are
  stored in the format (binary format) in which
  they are stored in the main memory.

35
Object I/O

• We can also store objects just as we can store
  primitive data values.
• To write objects to a file, we use
  ObjectOutputStream.
• To read objects from a file, we use
  ObjectInputStream.

36
Object I/O

• In this example, we will write Person objects to
  a file.
• The first step is to modify the Person class
  definition to allow ObjectOutputStream and
  ObjectInputStream to perform object I/O.

37
Serializable Interface

• We modify the definition by adding the phrase
  implements Serializable to it.
• import java.io.
• class Person implements Serializable
• //the rest is the same
• There are no methods for us to define in the
  implementation class.

38
Object Output

• To save objects to a file, we first create an
  ObjectOutputStream object
• File outFile new File(objects.dat)
• FileOutputStream outFileStream new
  FileOutputStream(outFile)
• ObjectOutputStream outObjectStream
• new ObjectOutputStream(outFileStream)

39
Object Output

• To save a Person object, we execute
• Person person new
• Person(Mr. Espresso, 20, M)
• outObjectStream.writeObject(person)

40
Object Output

• Different types of objects may be saved to a
  single file.
• We can also mix objects and primitive data type
  values in the same file.
• If a file contains objects from different
  classes, they must be read in the correct order
  and the matching type casting must be applied.

41
Object Input

• To read objects from a file, we use
  FileInputStream and ObjectInputStream.
• We use the method readObject to read an object.
• Because we can store any types of objects to a
  single file, we must type cast the object read
  from the file.
• The readObject method can throw a
  ClassNotFoundException (wrong type casting) in
  addition to an IOException.
• Either exception may be caught or propagated.