1 / 59

Files and Streams

Files and Streams. 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. Introduction.

kalila
Download Presentation

Files and Streams

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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.

More Related