Files and Streams

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”); • True • 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”); • True • 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”); • True • 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(“ \\ \\ “); • P: • mydata.dat • file • Programs • new • 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(“ \\ \\ “); • P: • mydata.dat • file • Programs • new • File F C E A D B

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/O High level I/O Text 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 object Step 3: Declare an array to keep input data, allocate memory for this array Step 4: Read data and process data if needed Step 5: Close the file

20. //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(); Sample: Low-Level File Input

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

22. //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(); Sample: Low-Level File Output

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 object Step 3: Create a BufferedReader object 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 <variable_name> = new FileReader(<name of a File ojbect>); How to create a BufferedReader object: BufferedReader <variable_name> = new BufferedReader(<name of a FileReader object); How to read a line <bufferedReader object name>.readLine();

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

33. Create a FileOutputSTream and PrintWriter objects • How to create a FileOutputStream objects: FileOutputStream <variable_name> = new FileOutputStream(<name of a File object>); • How to create a PrintWriter object PrintWriter <variable_name> = new PrintWriter(<name of a FileOutputStream object>); • How to write a string to a file <A print writer object>.println(<string object name>); 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.