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 exampleJava byte code (.class file)

The file displayed below is a Word document. What type of file is it?

A.TextB.BinaryC.NeitherD.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

• Constructing a PrintWriter object on a specific FileOutputStream is called opening a fileopening 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 exampleScanner 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

Exampleimport 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

ExampleString 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()

Exampleimport 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

ExampleScanner inFile = new Scanner (new FileInputStream(“somefile.txt”));String input;

while (inFile.hasNextLine()){

input = inFile.nextLine();

// processing of input can occur here

}

inFile.close();