File input and output

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