1. Files and Streams

2. Midterm exam Time: Wednesday, October 31, 2007 Format: Multiple choices (about 15 to 20 questions) Determine the results of the code Writing a piece of code Cover: Fundamental of Java, Array, Search and Sort, String, Error handling

3. Introduction Storage of data in variables and arrays is temporary Files used for long-term retention of large amounts of data, even after the programs that created the data terminate Persistent data – exists beyond the duration of program execution Why is File I/O important?

4. Review The following two statements will associate file 1 and file 2 to the same file: File file1=new File(“c:\\one\\two”,”three.dat”); File file2 = new File(“c:\\one\\two\\three.dat”); a. True b. False

5. Review The following two statements will associate file 1 and file 2 to the same file: File file1=new File(“c:\\one\\two”,”three.dat”); File file2 = new File(c:\\one\\two\\three.dat”); a. True b. False

6. Review The following two statements will associate file 1 and file 2 to the same file: File file1=new File(“c:\\one\\two”,”three.dat”); File file2 = new File(c:\\one\\two\\three.dat”); a. True b. False

7. Review Complete a code fragment that will create a File object and associate it to an existing file named mydata.dat in the Programs directory of a windows network P: drive = File(“ \\ \\ “); a. P: b. mydata.dat c. file d. Programs e. new f. File

8. Review Complete a code fragment that will create a File object and associate it to an existing file named mydata.dat in the Programs directory of a windows network P: drive = File(“ \\ \\ “); a. P: b. mydata.dat c. file d. Programs e. new f. File FCE ADB

9. Java and File Input/Output Files stored on secondary storage devices Stream – ordered data that is read from or written to a file Java views each files as a sequential stream of bytes

10. Files and Streams Operating system provides mechanism to determine end of file End-of-file marker Count of total bytes in file Java program processing a stream of bytes receives an indication from the operating system when program reaches end of stream

11. Files and Streams File streams Byte-based streams – stores data in binary format Binary files – created from byte-based streams, read by a program that converts data to human-readable format Character-based streams – stores data as a sequence of characters Text files – created from character-based streams, can be read by text editors

12. Files and Streams Java opens file by creating an object and associating a stream with it Standard streams: System.in – standard input stream object System.out – standard output stream object, System.err – standard error stream object

13. Files and Streams java.io classes FileInputStream and FileOutputStream – byte-based I/O FileReader and FileWriter – character- based I/O ObjectInputStream and ObjectOutputStream – used for input and output of objects or variables of primitive data types File – useful for obtaining information about files and directories

14. Files and Streams Classes Scanner and Formatter Scanner – can be used to easily read data from a file Formatter – can be used to easily write data to a file (needs j2se 5.0 to run)

15. Java’s view of a file of n bytes.

16. Overview of old knowledge of File I/O Low level I/OHigh level I/OText file I/O Treat a file As a set of bytes Treat A file As a set of data of primitive Data type Treat A file As a set of text (or String)

17. Low-Level File I/O 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. 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.

18. Streams for Low-Level File I/O 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. FileInputStream allows us to read in an array of bytes.

19. Low level data input Step 1: Create a File object Step 2: Create a FileInputStream objectFileInputStream Step 3: Declare an array to keep input data, allocate memory for this array Step 4: Read data and process data if neededRead data Step 5: Close the file

20. Sample: Low-Level File Input //set up file and stream File inFile = new File("sample1.data"); FileInputStream inStream = new FileInputStream(inFile); //set up an array to read data in int fileSize = (int)inFile.length(); byte[] byteArray = new byte[fileSize]; //read data in and display them inStream.read(byteArray); for (int i = 0; i < fileSize; i++) { System.out.println(byteArray[i]); } //input done, so close the stream inStream.close();

21. Low level data output Step 1: Create a File object Step 2: Create a FileOutputStream objectFileOutputStrea Step 3:Get data ready Step 4:Write data to output streamWrite data Step 5: Close the file

22. Sample: Low-Level File Output //set up file and stream File outFile = new File("sample1.data"); FileOutputStream outStream = new FileOutputStream( outFile ); //data to save byte[] byteArray = {10, 20, 30, 40, 50, 60, 70, 80}; //write data to the stream outStream.write( byteArray ); //output done, so close the stream outStream.close();

23. Streams for High-Level File I/O FileOutputStream and DataOutputStream are used to output primitive data values FileInputStream and DataInputStream are used to input primitive data values To read the data back correctly, we must know the order of the data stored and their data types

24. Setting up DataOutputStream A standard sequence to set up a DataOutputStream object:

25. Sample Output import java.io.*; class Ch12TestDataOutputStream { public static void main (String[] args) throws IOException {... //set up outDataStream //write values of primitive data types to the stream outDataStream.writeInt(987654321); outDataStream.writeLong(11111111L); outDataStream.writeFloat(22222222F); outDataStream.writeDouble(3333333D); outDataStream.writeChar('A'); outDataStream.writeBoolean(true); //output done, so close the stream outDataStream.close(); }

26. Setting up DataInputStream A standard sequence to set up a DataInputStream object:

27. Sample Input import java.io.*; class Ch12TestDataInputStream { public static void main (String[] args) throws IOException {... //set up inDataStream //read values back from the stream and display them System.out.println(inDataStream.readInt()); System.out.println(inDataStream.readLong()); System.out.println(inDataStream.readFloat()); System.out.println(inDataStream.readDouble()); System.out.println(inDataStream.readChar()); System.out.println(inDataStream.readBoolean()); //input done, so close the stream inDataStream.close(); }

28. Reading Data Back in Right Order The order of write and read operations must match in order to read the stored primitive data back correctly.

29. Textfile Input and Output Instead of storing primitive data values as binary data in a file, we can convert and store them as a string data. This allows us to view the file content using any text editor To output data as a string to file, we use a PrintWriter object To input data from a textfile, we use FileReader and BufferedReader classes From Java 5.0 (SDK 1.5), we can also use the Scanner class for inputting text files

30. Read data from a text file Step 1: Create a File object Step 2: Create a FileReader objectFileReader Step 3: Create a BufferedReader objectBufferedReader Step 4: Read line by line Step 5: Convert String object to primitive data type as necessary Step 6: Close the file

31. Create FileReader and BufferedReader objects How to create a FileReader ojbect: FileReader = new FileReader( ); How to create a BufferedReaderobject: BufferedReader = new BufferedReader(<name of a FileReader object); How to read a line.readLine();

32. Write data to a text file Step 1: Create a File object Step 2: Create a FileOutputStream objectFileOutputStream Step 3: Create a PrintWriter objectPrintWrite Step 4: Write line(s) Step 5: Close the file

33. Create a FileOutputSTream and PrintWriter objects How to create a FileOutputStream objects: FileOutputStream = new FileOutputStream( ); How to create a PrintWriter object PrintWriter = new PrintWriter( ); How to write a string to a file.println( ); More details on this link

34. Example import java.io.*; public class OutputExample{ public static void main (String[] args) throws IOException { File inFile = new File("e:\\Temp\\output.dat"); FileOutputStream fileStream = new FileOutputStream(inFile); PrintWriter printWriter = new PrintWriter(fileStream); String inputStr; int number[] = new int[10]; for (int i=0;i<number.length; i++) { number[i] = i+1; printWriter.println(number[i]); } printWriter.close(); System.exit(0); }

35. Example import java.io.*; public class OutputExample{ public static void main (String[] args) throws IOException { File inFile = new File("e:\\Temp\\output.dat"); FileOutputStream fileStream = new FileOutputStream(inFile); PrintWriter printWriter = new PrintWriter(fileStream); String inputStr; int number[] = new int[10]; for (int i=0;i<number.length; i++) { number[i] = i+1; printWriter.println(number[i]); } printWriter.close(); System.exit(0); } Step 1-3

36. Example import java.io.*; public class OutputExample{ public static void main (String[] args) throws IOException { File inFile = new File("e:\\Temp\\output.dat"); FileOutputStream fileStream = new FileOutputStream(inFile); PrintWriter printWriter = new PrintWriter(fileStream); String inputStr; int number[] = new int[10]; for (int i=0;i<number.length; i++) { number[i] = i+1; printWriter.println(number[i]); } printWriter.close(); System.exit(0); } Step 4 (in for loop)

37. Example import java.io.*; public class OutputExample{ public static void main (String[] args) throws IOException { File inFile = new File("e:\\Temp\\output.dat"); FileOutputStream fileStream = new FileOutputStream(inFile); PrintWriter printWriter = new PrintWriter(fileStream); String inputStr; int number[] = new int[10]; for (int i=0;i<number.length; i++) { number[i] = i+1; printWriter.println(number[i]); } printWriter.close(); System.exit(0); } Step 5 (close file)

38. File Input and Output Sequential-access files Random-access files

39. Sequential-Access Text Files Each line describes a record in a database. Records are stored in order by record-key field Can be created as text files or binary files Input files: Programmer must structure files Output files: Formatter class can be used to open a text file for writing

40. Create a text file using Formatter class Step 1: Pass name of file to constructor If file does not exist, will be created If file already exists, contents are truncated (discarded) Step 2: Use method format to write formatted text to file Step 3: Use method close to close the Formatter object (if method not called, OS normally closes file when program exits)

41. Practice Step 1: Create a package called Lab7 under your Labs project. Select Lab7 package -> New class -> AccountRecord. Then cut and paste the content of AccountRecord.java in D2L to this AccountRecord class. Step 2: Select Lab7 package -> New class -> CreateTextFile. Then cut and paste the content of CreateTextFile class in D2L to this newly created class. Step 3. Select Lab7 package -> New class -> CreateTextFileMain class.

42. Practice Step 4: In CreateTextFileMain class, add the main method, in which you should: - create a CreateTextFile object - using this object to open a file, add records and write to a file.

43. End-of-file key combinations for various popular operating systems.

44. Reading Data from a Sequential- Access Text File Data is stored in files so that it may be retrieved for processing when needed Scanner object can be used to read data sequentially from a text file Pass File object representing file to be read to Scanner constructor FileNotFoundException occurs if file cannot be found Data read from file using same methods as for keyboard input – nextInt, nextDouble, next, etc. IllegalStateException occurs if attempt is made to read from closed Scanner object

45. Practice Step 1: Under your Lab7 package, create a new class ReadTextFile. Then cut and paste the content of ReadTextFile.java in D2L to this class. Step 2: Select Lab7 package -> New class -> ReadTextFileMain class. In this class, you should create a ReadTextFile object - using this object to open a file, read records from a text file and close that file.

46. Updating Sequential-Access Files Data in many sequential files cannot be modified without risk of destroying other data in file Old data cannot be overwritten if new data is not same size Records in sequential-access files are not usually updated in place. Instead, entire file is usually rewritten.

47. Practice Exercise for Midterm exam

48. Random-Access Files Sequential-access files inappropriate for instant-access applications Instant-access applications are applications in which desired information must be located immediately Instant access possible with random-access files (also called direct-access files) and databases

49. Random-Access Files Data can be inserted in random-access file without destroying other data Different techniques for creating random-access files Simplest: Require that all records in file be same fixed length Easy to calculate (as a function of record size and record key) exact location of any record relative to beginning of file

50. Java’s view of a random- access file.

51. Creating a Random-Access File RandomAccessFile class Includes all capabilities of FileInputStream and FileOutputStream Includes capabilities for reading and writing primitive-type values, byte arrays and strings Using RandomAccessFile, program can read or write data beginning at location specified by file-position pointer

52. Creating a Random-Access File RandomAccessFile class Manipulates all data as primitive types Methods readInt, readDouble, readChar used to read integer, double and character data from file Methods writeInt, writeDouble, writeChars used to write integer, double and string data to file File-open mode – specifies whether file is opened for reading ( “r” ), or for both reading and writing ( “rw” ). File- open mode specified as second argument to RandomAccessFile constructor

53. Practice Step 1: Create a package called Lab7 under your Labs project. Select Lab7 package -> New class -> RandomAccessAccountRecord. Then cut and paste the content of RandomAccessAccountRecord.java in D2L to this class. Step 2: Select Lab7 package -> New class -> CreateRandomFile. Then cut and paste the content of CreateRandomFile class in D2L to this newly created class. Step 3. Select Lab7 package -> New class -> CreateRandomFileMain class.

54. Practice Step 4: In CreateRandomFileMain class, add the main method, in which you should: - create a CreateRandomFile object - using this object to create a file.

55. Writing Data Randomly to a Random- Access File RandomAccessFile method seek positions file-position pointer to a specific location in a file relative to beginning of file Size of each record is known, so location in file of a specific record can be found by multiplying size of record with number of record

56. Writing Data Randomly to a Random- Access File Once location known, new record data can be written without worrying about rest of file, as each record is always same size

57. Practice Step 1: Select Lab7 package -> New class -> WriteRandomFile. Then cut and paste the content of WriteRandomFile class in D2L to this newly created class. Step 3. Select Lab7 package -> New class -> WriteRandomFileMain class in which we - create a WriteRandomFile object - using this object to open file, add records and write to a random-access file.

58. Reading Data Sequentially from a Random-Access File Open file with “r” file-open mode for reading Ignore empty records (usually those with account number of zero) when reading from file

59. Reading Data Sequentially from a Random-Access File Records stored by account number in random-access files have added bonus of being sorted, as each record’s data can only be placed in specific portion of file Sorting with direct-access techniques is blazingly fast—speed achieved by making file large enough to hold every possible record Space/time trade-off