Lecture 31: I-O Stream-II

Summary

The lecture demonstrates how Java I/O classes are used to read input, inspect files, and transfer data between programs and files. It covers keyboard input, the File class, byte and character streams, primitive-data streams, and combining file streams.

1. Reading keyboard input

• The example connects a program to standard input—the keyboard—using System.in and a DataInputStream.
• The lecture uses readLine() to read an entire line of input as text.
• Because the input is read as a string, it must be converted before calculations:
  • Use methods such as Float.parseFloat() to convert text into a floating-point value.
  • Use Integer.parseInt() to convert text into an integer.
• The example applies this process to read values such as principal, interest rate, and number of years for an interest calculation.

2. Working with the File class

The java.io.File class represents a file or directory and provides ways to refer to it and inspect it.

• A File object can be created using a file name, a path and file name, or a directory and file name.
• The path determines where Java looks for the file, so the file name must be specified correctly.
• File operations may fail—for example, if a file does not exist or the program lacks permission—so the lecture emphasizes handling exceptions with try/catch.
• The lecture surveys methods that can:
  • Retrieve a file’s name, path, absolute path, and parent directory.
  • Check whether the file exists, is readable, or is writable.
  • Determine whether it is a file or a directory.
  • Retrieve its last-modified time and length.
  • Rename or delete it.
  • Create directories and list directory contents.
• A sample program takes file names from command-line arguments and prints information about each one.

3. Reading and writing bytes

Byte streams are used for file data handled as bytes.

• Reading: FileInputStream reads bytes from a file. The lecture shows several approaches:
  • Read one byte at a time until the end of the file.
  • Use available() to obtain an estimate of the bytes available to read.
  • Read a block of bytes into an array, then convert or display the data.
  • Use skip() to move past a specified number of bytes.
• Writing: FileOutputStream writes a byte array to a file.
  • If the target file already exists, the examples overwrite its previous contents.
  • The stream should be closed after the operation is complete.
• The same byte-stream approach can copy data from one file to another by reading from a FileInputStream and writing to a FileOutputStream.

4. Reading and writing characters

Character streams are an alternative for working with text.

• FileReader reads characters from an input file, while FileWriter writes characters to an output file.
• A copy operation can read one character at a time until the end of the input file and write each character to the output file.
• The lecture notes that the output file is overwritten in the example rather than appended to.
• Byte and character streams follow similar patterns but operate on different units of data.

5. Reading and writing primitive values

The lecture introduces DataOutputStream and DataInputStream for writing and reading primitive data types.

• A DataOutputStream is connected to a file output stream and can write values such as integers, floating-point numbers, booleans, and characters using type-specific methods.
• A corresponding DataInputStream can read those values back.
• Values must be read in the same order and with matching types to the order and types used when writing them.
• An example generates random numbers, stores them in a file, and then reads them back.

6. Combining streams

• The lecture demonstrates SequenceInputStream as a way to combine input from two files into one sequential stream.
• The combined stream can then be buffered and read or displayed as a single sequence of data.

7. General programming practices

• Choose a stream suited to the data: byte streams for bytes, character streams for text, and data streams for typed primitive values.
• Handle file-related exceptions, since opening or accessing a file can fail.
• Close streams after use.
• Keep the reading format consistent with the way the data was written.

The lecture briefly distinguishes sequential file access from random access. Random-access file handling is reserved for a later module.

Speakers and sources featured

• Speaker: One unnamed lecturer; no additional speakers are identifiable in the subtitles.
• Source/organization: NPTEL IIT Kharagpur.
• Technical sources discussed: Java I/O classes and packages, including java.io and java.lang.