Chapter 12 File Input and Output

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

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

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.

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.

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.

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.

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.

I/O Classes Keyboard input and console output

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

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

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

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

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

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.

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

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 }

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 i=0; i<filename.length; i++){ System.out.println(filename[i]); } To determine if a File object is associated to a file or directory, we call its boolean method isFile

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.

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.

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

File Filters A file filter may be used to remove unwanted files from the list. Define a subclass of the javax.swing.filechooser.FileFilter 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.

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

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.

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.

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.

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(inFile); Next declare and create byteArray: int filesize = (int) inFile.length(); byte[] byteArray = new byte[filesize];

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

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.

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.

Classes for Binary Files

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.

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.

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.

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.

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.

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.

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

Object Output To save a Person object, we execute Person person = new Person(“Mr. Espresso”, 20, ‘M’); outObjectStream.writeObject(person);

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.

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.