files and streams n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Files and Streams PowerPoint Presentation
Download Presentation
Files and Streams

Loading in 2 Seconds...

play fullscreen
1 / 59

Files and Streams - PowerPoint PPT Presentation


  • 99 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Files and Streams' - kalila


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
midterm exam
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
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?

review
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
review1
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
review2
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
review3
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
review4
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

java and file input output
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
files and streams1
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
files and streams2
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
files and streams3
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
files and streams4
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
files and streams5
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)
overview of old knowledge of file i o
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)

low level file i o
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.
slide18

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.
slide19

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

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

Sample: Low-Level File Input
slide21

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

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

Sample: Low-Level File Output
streams for high level file i o
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
setting up dataoutputstream
Setting up DataOutputStream
  • A standard sequence to set up a DataOutputStream object:
sample output
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();

}

}

setting up datainputstream
Setting up DataInputStream
  • A standard sequence to set up a DataInputStream object:
sample input
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();

}

}

reading data back in right order
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.
textfile input and output
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
read data from a text file
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

create filereader and bufferedreader objects
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();

write data to a text file
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

create a fileoutputstream and printwriter objects
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

example
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);

}

}

example1
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

example2
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)

example3
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)

file input and output
File Input and Output

Sequential-access

files

Random-access

files

sequential access text files
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
create a text file using formatter class
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)
practice
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.

practice1
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.

reading data from a sequential access text file
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
practice2
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.

updating sequential access files
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.
random access files
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
random access files1
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
creating a random access file
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
creating a random access file1
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
practice3
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.

practice4
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.

writing data randomly to a random access file
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
writing data randomly to a random access file1
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
practice5
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.

reading data sequentially from a random access file
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
reading data sequentially from a random access file1
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