File Input and Output - PowerPoint PPT Presentation

1 / 41
About This Presentation
Title:

File Input and Output

Description:

FileOutputStream outStream = new FileOutputStream(outFile) ... outstream.write(byteArray); After the values are written to the file, we must close the stream: ... – PowerPoint PPT presentation

Number of Views:24
Avg rating:3.0/5.0
Slides: 42
Provided by: amyh99
Learn more at: http://cs.boisestate.edu
Category:
Tags: file | input | output | outstream

less

Transcript and Presenter's Notes

Title: 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.
Write a Comment
User Comments (0)
About PowerShow.com