File I/O There’s more to life than the keyboard

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

Stream objects In Java, as in many programming languages, we envision data flowing past our program in a stream –Data coming into a program comes from one or more input streams –Data coming out of a program goes to one or more output streams A stream object can represent an input or output device (such as the keyboard or screen), but it can also represent a secondary storage location – in other words, a file

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

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

File types Text files are human-readable collections of data, which can be created (saved) and retrieved (opened) using a text editor Binary files are usually not human- readable; rather, they are collections of bits arranged in a format that can be read or written using a specific application program

Example – text file A text file (source code from a Java program)

Binary file example Java byte code (.class file)

The file displayed below is a Word document. What type of file is it? A.Text B.Binary C.Neither D.Both

Text files vs. binary files Text files are coded in ASCII, and are therefore usually readable across different hardware platforms & applications Binary files can be processed more efficiently by their native programs than text files, but are often platform & application-dependent Java binary files are platform-independent; you can read them on any computer that has a Java Virtual Machine and the application code

Text file I/O We’ll begin by looking at the simplest case: writing text data to a file When you intend to read or write files, you will need to use classes and methods from the java.io package, so begin with the following import statement: import java.io.*;

PrintWriter and FileOutputStream An object of type PrintWriter is the preferred means to represent a text file output stream, The PrintWriter constructor requires a parameter of type FileOutputStream, which in turn has a constructor that requires a String parameter, specifiying a file name opening a fileConstructing a PrintWriter object on a specific FileOutputStream is called opening a file

Example – opening an output file I want to write some data to a file in the same folder as my program’s byte code; the file name is MyData.txt I could use the following syntax to open the file (by creating a PrintWriter object named myFile): PrintWriter myFile = new PrintWriter(new FileOutputStream(“MyData.txt”);

Breaking down the example On the previous slide, two objects were created: –an anonymous FileOutputStream object –a PrintWriter object In creating the first object, a FileNotFoundException (a subtype of IOException) can be thrown – this is a checked exception, so it must be handled with either a try/catch block or a throws clause

Variation on example It makes sense to use an anonymous FileOutputStream object (because it isn’t used anywhere else in the program) to create the PrintWriter object However, it is really the creation of the FileOutputStream that throws the exception, and we could isolate just this line of code if we wanted to place it in a try block, as shown on the next slide

Variation on example Scanner kb = new Scanner(System.in); String fileName; System.out.print (“Enter name for output file: “); fileName = kb.nextLine(); PrintWriter myFile; FileOutputStream myStream; try { myStream = new FileOutputStream(fileName); } catch (FileNotFoundException e) { System.out.println (“File could not be opened for output; closing program”); System.exit(1); } // ends catch block myFile = new PrintWriter(myStream);

Notes on files & file organization under Windows The way files are organized and stored on a computer depends on the computer’s operating system Under windows, disk drives (both physical and virtual, such as partitions or network drives) are designated with a letter: –C: is usually the computer’s primary hard drive –A: is usually the floppy drive, if one exists

Each disk is organized into a set of directories, or folders, with alphanumeric names A folder can contain files and/or more folders, called subdirectories We differentiate between a subdirectory and its containing directory, or a file and its containing directory, using backslash separators Notes on files & file organization under Windows

Examples A file named text.txt in the documents subdirectory of the mystuff directory on the C: drive of the computer would be written as: C:\mystuff\documents\text.txt A file named file.txt on a floppy disk, in the main directory, would be: A:\file.txt

Windows file names & Java programs The examples on the previous slide illustrate what a user should type in response to the prompt, “Enter a file name:” Originally, we saw an example in which the file name was hard-coded into the program: PrintWriter myFile = new PrintWriter(new FileOutputStream(“MyData.txt”);

Windows file names & Java programs As the example indicated, the file in question “MyData.txt” was in the same directory as the Java program If you want to hard-code a file name from a different disk or folder into a Java program, you need to be careful with the backslash (\) character As we know, a backslash followed by a single character indicates an escape, or control character – for example, \n is the newline character

Windows file names & Java programs To hard-code the name of a file in a different folder or disk than your program, use two backslashes wherever a backslash should appear; for example: PrintWriter myFile = new PrintWriter(new FileOutputStream(“C:\\TextFiles\\MyData.txt”);

Writing output to text files Once a PrintWriter object has been instantiated, writing output to an open file is as simple as writing output to the screen The methods print, println, and printf can be called on the PrintWriter object, just as they can be called on System.out You can still call these same methods from System.out, so you can write to either a file or the screen in the same program

Other PrintWriter methods The close() method closes the stream’s connection to a file; it should be called before ending a program with an open file Note that the same PrintWriter object can be used to open multiple files – you just have to close one file before you open another If you wish to write to a file and read from it later, you must close it as an output file before opening it as an input file The flush() method can be called to force a write to a file – this will clear the output buffer of all data currently in it

Example import java.io.*; import java.util.*; public class WriteMyFile { public static void main (String [] args) throws FileNotFoundException { Scanner kb = new Scanner(System.in); String fName; System.out.print(“Enter output file name:”); fName = kb.nextLine(); PrintWriter pw = new PrintWriter(new FileOutputStream(fName)); System.out.println(“Here it is on the screen”); pw.println(“And here it is in the file”); pw.close(); }

Overwriting vs. appending to output files The way you open a file (by calling the FileOutputStream constructor) determines whether you will create a new file, overwrite an existing file, or add contents to an existing file If you call the constructor as we have been doing, with a single String argument, you will either create a new file or overwrite an existing one – the latter if a file by the specified name already exists If you call the constructor with two arguments – a String and a true boolean expression – you will instead open the file to append to it, rather than replace it

Example Suppose the file created in the WriteMyFile example exists in the root directory of drive A and contains the text “And here it is in the file” The following code: PrintWriter pw = new PrintWriter (new FileOutputStream(“A:\\myFile.txt”, true)); pw.println(“And here we go again”); pw.close(); would add text to the file; its contents would now be: And here it is in the file And here we go again

General notes on examples All of the examples so far have opened a file, written a single line to it, then closed the file The examples are set up as they are to keep them short – they aren’t typical Normally, we would write several lines of output to a file, first opening it, then closing it when our output is finished In general, a file output stream is just like the standard output stream – we just have to remember to open it before we can use it, and close it when we’re done

Reading input from a text file Can use the same Scanner class we use for keyboard input to read from a text file When reading from the keyboard, we create the Scanner object by passing its constructor an object representing the standard input stream: Scanner kb = new Scanner (System.in); To read from a test file, we construct it by passing a FileInputStream object instead – in other words, we open an input file much the same way we open an output file

Syntax & example General syntax: Scanner scanner = new Scanner (new FileInputStream(name)); Example: Scanner input = new Scanner (new FileInputStream(“C:\\myfiles\\data.txt”));

Notes on opening input files Instantiating a FileInputStream object can throw the same type of exception (FileNotFoundException) as with a FileOutputStream object As with output files, we can break down the process of opening an input file into smaller pieces; see next slide

Example String fileName; Scanner kb = new Scanner (System.in); System.out.print(“Enter name of input file: ”); fileName = kb.nextLine(); try { FileInputStream inFileStream = new FileInputStream(fileName); } catch (FileNotFoundException e) { System.out.println(“Could not open input file – ending program”); System.exit(1); } Scanner inFile = new Scanner(inFileStream);

Scanner methods Once a Scanner object is open, you can call the same methods to read data from an input file as you have used to read data from the keyboard –for integers: nextInt() –for doubles: nextDouble() –for Strings: next() and nextLine()

More Scanner methods The Scanner class has several “look ahead” methods that can be used to determine: –whether or not there is more input to come –the nature of the input (number vs. text) All of the following methods return a boolean value: –hasNextInt() –hasNextDouble() –hasNext()

Example import java.util.*; public class IOTest { public static void main (String [] args) { Scanner kb = new Scanner (System.in); boolean end = false; while (!end) { System.out.print("Enter some text; enter a number to quit: "); if (kb.hasNextDouble()) end = true; else { String input = kb.nextLine(); System.out.println ("You entered: " + input); }

File input & EOF loops The previous example used the difference between text and numeric input to determine the end of keyboard data A more realistic, and much more common application, is the use of the hasNext() method(s) to determine whether or not there is more data to be read from a file

Example Scanner inFile = new Scanner (new FileInputStream(“somefile.txt”)); String input; while (inFile.hasNextLine()) { input = inFile.nextLine(); // processing of input can occur here } inFile.close();