1. File input and output

2. Interactive vs. file I/O All of the programs we have seen or written thus far have assumed interaction with a user, who types in data at a keyboard and sees output on a screen We can also receive data from, or send data to, the secondary storage devices on the computer This type of input and output is called file I/O

3. File I/O 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. Both of these actions involve interacting with the operating system and its file structure

4. The file concept We can envision a file as a special kind of container that can hold a collection of data or instructions A file can also contain a collection of other files: such a file is called a directory or folder An important point to remember is that Java considers a folder to be just another file

5. File system organization Under Windows and most other modern operating systems, information is stored on disk in a hierarchically ordered structure consisting of directories, subdirectories, and files Disks are designated using letters – for example, C is typically the computer’s hard drive (or its primary partition), while A is traditionally a floppy disk The Windows GUI portrays directories as folders, which can contain other folders or files

6. Windows file system example The illustration below depicts a typical file system structure under Windows

7. Opening a file for input or output Before we can read data from a file, we must create a File object and associate it to the file from which we wish to read. –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. We do this by calling a File constructor

8. Opening a file The simplest syntax for opening a file is: File aFile = new File (“filename”); –The String argument designates the name of the file (as seen by the operating system) –This syntax assumes that the argument is the name of a file (not a folder), and that the file is located in the same folder as the program’s code file

9. Opening a file Slightly more complicated syntax is necessary if the file to be opened is in a different folder: File aFile = new File (“path”, “file”); –The first argument specifies the disk and file system hierarchy that contains the file –For example, if the file is in directory G:\shared\cate\cs1, you would write: File aFile = new File (“g:/shared/cate/cs1”, “file”); Note the use of the forward slash; you can use either this format or: File aFile = new File (“g:\\shared\\cate\\cs1”, “file”);

10. Opening a file A File object may also be associated to a directory. As far as Java is concerned, a directory is just a special kind of file The code on the next slide illustrates the use of a File object to open a directory, then list the names of all the files in the directory

11. Example File directory = new File (“C:/JavaPrograms/Ch12”); String filename[] = directory.list(); // Returns an array of strings naming the files and // directories in the directory denoted by this pathname for (int i=0; i<filename.length; i++){ System.out.println(filename[i]); }

12. File methods The previous slide illustrated the use of the list() method, which returns an array of Strings containing the names of files within a directory Several other useful methods of the File class are listed in the Java API; we will examine a few of these

13. File methods 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 } It is particularly useful to check input files to see if they actually exist before we try to read from them

14. File methods To determine if a File object is associated to a file or directory, we call its boolean method isFile. A similar method, isDirectory, returns true if the File object is associated with a folder instead of an ordinary file.

15. Choosing a file from a list A javax.swing.JFileChooser object allows the user to select a file from a list of available files. The code fragment below illustrates how this is done: JFileChooser chooser = new JFileChooser();... chooser.showOpenDialog(null);

16. A JFileChooser object displayed with the showOpenDialog method

17. JFileChooser Object methods The getSelectedFile method retrieves the desired file. The getName and getAbsolutePath methods retrieve the name and full path of a selected file (similar methods exist for File objects). The showSaveDialog method displays a JFileChooser with a Save button.

18. A JFileChooser object displayed with the showSaveDialog method

19. JFileChooser Example The next couple of slides display a program that uses JFileChooser objects to display a list of files, then allow the user to choose which file should be open for output Note the use of File and JFileChooser methods in the code

20. import java.io.*; import javax.swing.*; public class TestJFileChooser { public static void main (String[] args) { JFileChooser chooser; File file, directory; int status; chooser = new JFileChooser( ); status = chooser.showOpenDialog(null); if (status == JFileChooser.APPROVE_OPTION) { file = chooser.getSelectedFile(); directory = chooser.getCurrentDirectory(); System.out.println("Directory: " + directory.getName()); System.out.println("File selected to open: " + file.getName()); System.out.println("Full path name: " + file.getAbsolutePath()); } else { JOptionPane.showMessageDialog(null, "Open File dialog canceled"); }

21. System.out.println("\n\n"); status = chooser.showSaveDialog(null); if (status == JFileChooser.APPROVE_OPTION) { file = chooser.getSelectedFile(); directory = chooser.getCurrentDirectory(); System.out.println("Directory: " + directory.getName()); System.out.println("File selected for saving data: " + file.getName()); System.out.println("Full path name: " + file.getAbsolutePath()); } else { JOptionPane.showMessageDialog(null, "Save File dialog canceled"); }

22. Sample output from running the TestJFileChooser program

23. Reading and Writing Files Once a file is opened by associating a File object to it, we can access 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. 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.

24. Reading and Writing Files An input stream has a source from which the data items come, and an output stream has a destination to which the data items are going. 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.

25. Writing Data to a File To send output to a file, do the following: –Create and open a File object File output = new File(“C:/datafiles”, “stuff”); –Associate a new FileOutputStream object with the File object FileOutputStream outs = new FileOutputStream(output); –Write the desired data to the FileOutputStream object byte [] snacks = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; outs.write(snacks); –Close the File stream outs.close();

26. The importance of closing a file If the stream object is not closed, then data may get lost due to 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.

27. The importance of closing a file 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.

28. Reading Data from a File To read data into a program, we reverse most of the steps in the output routine. We use the read method of FileInputStream to read in an array of bytes. First we create a FileInputStream object: File inFile = new File(“sample1.data”); FileInputStream inStream = new FileInputStream(inFile); Then we must declare and create an array to hold the data: int filesize = (int) inFile.length(); byte[] byteArray = new byte[filesize];

29. Reading Data from a File We 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 the array of bytes: inStream.read(byteArray);

30. Low-level File I/O The read and write methods of the FileInputStream and FileOutputStream classes read and write entire arrays of bytes, as we have seen We can output data other than bytes 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.

31. High-level File I/O Using DataOutputStream allows us to output Java primitive data type values by converting the 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; instead, its role is to provide high-level access to a file by handling the data type conversions.

32. Relationship between File and output Stream objects

33. High-Level File I/O 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. Relationship between File object and input Stream objects

35. High-Level File I/O 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. Data may be stored in ASCII format instead of binary format – this requires the use of a different set of objects

36. High-Level File I/O With ASCII format, all data are converted to string data. A file whose contents are stored in ASCII format is called a text file. To generate a textfile we use a PrintWriter is an object. PrintWriter supports only two output methods, which should look familiar: –print –println (for print line)

37. High-Level File I/O An argument to the methods may be any primitive data type. The methods convert the parameter to string and output this string value. The constructor of PrintWriter, like that of DataOutputStream, requires an output stream as its argument.

38. High-Level File I/O To read data from a text file, we use the FileReader and BufferedReader objects. –We first associate a BufferedReader object to a file. File inFile = new File(“sample3.data”); FileReader fileReader = new FileReader(inFile); BufferedReader brdr = new BufferedReader(fileReader); –Then we read data, using the readLine method of BufferedReader. String str = bufReader.readLine(); –Finally, we convert the String to a primitive data type as necessary (using wrapper classes as we’ve done before).

39. File I/O and Objects To write objects to a file, we use ObjectOutputStream. To read objects from a file, we use ObjectInputStream.

40. File I/O and Objects 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. We modify the definition by adding the phrase implements Serializable to it. import java.io.*; class Person implements Serializable { // the rest is the same }

41. File I/O and Objects 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);

42. File I/O and Objects To save a Person object, we execute: Person person = new Person(“Mr. Man”, 20, ‘M’); outObjectStream.writeObject (person ); 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.

43. File I/O and Objects 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.

44. File I/O and Objects The readObject method can throw a ClassNotFoundException (wrong type casting) in addition to an IOException. Either exception may be caught or propagated. If a file contains objects from different classes, they must be read in the correct order and the matching type casting must be applied.