GSEB Class 12 Solutions Chapter 11 File Handling

GSEB Computer Textbook Solutions Class 12 Chapter 11 File Handling

 

Question 1. Why is a file important in java programming ? Under what circumstances will you store the data in files ?
Answer: Files are very important in Java programming because they offer a way to store data permanently. You would usually store data in files when:
- You need information to stay available even after your program stops running.
- You want to share data between different programs or users.
- The amount of data is too large to keep in memory (RAM).
- You require data to be portable and easy to transfer.

Files can be further categorized broadly into two main groups:
(1) Text files and
(2) Binary files.

(1) Text files :

• Text files hold information that can be read in a simple text editor since the data has been encoded using a system such as ASCII or Unicode.
• Text files might be data files containing facts, like a payroll file with employee numbers, names, and salaries; or some text files can be program files or application files that store software instructions.
• Files created using editors such as gedit, vi, or pico are examples of text files. They often have extensions like txt, java, or c.

(2) Binary files :

• Binary files contain data that has not been converted into text.
• Their contents are in a binary layout, which means the information is retrieved byte by byte.
• Some common examples of binary file extensions include jpeg, mp3, and class files.

In simple words: Files are essential in Java to keep data safely even when the program closes, share data, and handle large amounts of information. There are two main kinds: text files (which you can read with a text editor) and binary files (which store raw computer data).

Exam Tip: Remember to explain both the 'why' (persistence, sharing, large data) and the 'when' (after program execution, for portability) aspects for full marks. Classifying file types is a good way to structure your answer.

 

Question 2. State various operations that can be performed on a file and directory.
Answer: Java offers support for various operations that can be carried out on files or directories. Here are some of the key operations that can be performed on files using Java programs:
1. Determining the path of a file or a directory.
2. Opening a file.
3. Writing to a file.
4. Reading from a file.
5. Closing a file.
6. Deleting a file.
7. Querying the attributes of a file.

• Java provides built-in classes that include methods to help with these tasks.
• These classes are located in the \( \text{java.io} \) package.
• Java utilizes the concept of streams, and it offers two distinct categories of Java classes to perform I/O operations on bytes and characters.

In simple words: Java lets you do many things with files and folders, like finding their location, opening, writing, reading, closing, deleting, and checking their details. It uses special tools from the \( \text{java.io} \) package to manage these tasks.

Exam Tip: List at least five common file operations (e.g., read, write, open, close, delete) and mention the \( \text{java.io} \) package to demonstrate comprehensive knowledge.

 

Question 3. Why is the concept of Streams introduced in java, give the advantages of using streams.
Answer: The concept of streams was introduced in Java primarily to provide a standardized, device-independent method for input/output (I/O) operations. This means that whether you are reading from a file, keyboard, or network, the code remains similar, simplifying data handling.

Introduction to Streams

• To change a file or show its contents, the idea of streams needs to be understood first.
• Java uses stream classes to carry out read and write actions on files. The different kinds of input and output devices must be considered.
• For example, a keyboard is an input device, while a monitor is an output device.

• A hard disk can be thought of as both an input and output device because data can be saved to and retrieved from files.
• There are various devices available on the market from different makers with different capabilities. For instance, hard disks are produced by many companies and come with various storage sizes, like 500GB or 1 TB. Besides this, hard disks can be connected using different cables, such as USB or SATA.
• However, a Java developer does not need to worry about the specific technical details, like the hard disk type or its size, when making a program to perform read/write actions on files.
• This is possible because the Java language offers the functionality of streams.
• A stream is an abstract representation of an input or output device that acts as a source or destination for data.
• Imagine a stream as a sequence of bytes that either flows into or out of the program. One can write or read data using these streams.
• When data is written to a stream, it is called an output stream.
• The output stream can move data from the program to a file on a hard disk, a monitor, or another computer over a network.
• An input stream is used to get data from an external device into the program. It can transfer data from a keyboard or from a file on a hard disk to the program.
• The primary reason for using streams for input or output tasks is to make our program independent of the devices involved.

Two advantages of streams are:
1. Programmers do not need to concern themselves with the technical details of the device.
2. The program can function with various input/output devices without requiring any changes to the source code.
In simple words: Streams simplify data flow by creating a universal way to handle input and output, no matter the device. This means programmers don't have to worry about specific device details, and programs can work easily with different input/output sources.

Exam Tip: When explaining streams, highlight their role in abstracting I/O details and enabling device independence, as these are key benefits for programmers.

 

Stream Classes In Java

• To grasp byte streams and character streams, one needs to distinguish between character and byte representation.
• An example of the number "5", which can be shown in two different ways, is presented in the table below.

 

Table: Character And Binary Representation

• A character is generally stored using ASCII or Unicode format, but when it is utilized for calculation purposes, its binary value becomes meaningful.
• For instance, the statement \( \text{int i = 32;} \) declares \( \text{T} \) as an integer-type variable that holds the number 32.
• However, 32 can be shown as two separate characters '3' and '2'. The character representation is better when sentences are written like “Human beings have 32 teeth”.
• In the above sentence, no calculation is needed with the number. But when it is used for numerical computations, data types like int, float, or double are employed, which allows storing the numbers in a binary format.
• Java supports two kinds of streams: byte streams and character streams.
• Streams that move data as bytes to a file or devices are called byte streams or binary streams.
• The files created using a byte stream are known as binary files. If variables like integer, double, or boolean need to be stored into a file, then binary files should be used.
• Binary files can also be used to store arrays or objects.
• Similarly, text files and program codes are created using a character stream. These can be opened in text editors like vi and SciTE.
• Java offers two sets of classes: character stream classes and binary stream classes.
• Character Stream classes found in the \( \text{java.io} \) package handle character/text data, while byte stream classes in the \( \text{java.io} \) package deal with binary data.
• The figure illustrates the classification of stream classes.

 

Figure: Classification Of Stream Classes

• Java streams can be categorized into two basic kinds: input stream and output stream.
• An input stream reads data from the source (like a file or keyboard), while an output stream writes data to the destination (like a file or output device).
• The \( \text{java.io} \) package includes a set of stream classes that enable reading and writing in a file. To utilize these classes, a program needs to import the \( \text{java.io} \) package.

 

Question 4. Choose the most appropriate option from those given below:
1) Which of the following statements is true ?
(a) Volatile storage lasts only a few seconds.
(b) Volatile storage is lost when a computer is shutdown.
(c) Computer disks are volatile storage devices.
(d) All of the options
Answer: (b) Volatile storage is lost when a computer is shutdown.
In simple words: Volatile storage, like RAM, only keeps data as long as the computer has power. When you turn off the computer, all the information in volatile storage disappears.

Exam Tip: Understand the difference between volatile (temporary, like RAM) and non-volatile (permanent, like hard drives) memory. This distinction is crucial for data persistence.

 

2) Which of the following refers to a collection of data stored on a nonvolatile device in a computer system ?
(a) File
(b) Application
(c) Volatile data
(d) Hard-disk
Answer: (a) File
In simple words: A file is a set of data stored on a device like a hard drive, where it stays even when the computer is turned off.

Exam Tip: Recall that "nonvolatile" means data persists without power. Files are the primary way to store such persistent data on storage devices.

 

3) The data hierarchy occurs in which of the following order from the smallest to largest piece of data ?
(a) file:character:field:record
(b) flle:character:record:field
(c) character:field:file:record
(d) character:field:record:file
Answer: (d) character:field:record:file
In simple words: The smallest unit is a character, then a field (like a name), then a record (a full entry), and finally many records make a file.

Exam Tip: Memorize the standard data hierarchy: character, field, record, file, database. This order is fundamental in data organization.

 

4) Which of the following is true about streams ?
(a) Streams always flow in two directions
(b) Streams are channels through which the data flow
(c) Only one stream can be open in a program at a time.
(d) All of the options
Answer: (b) Streams are channels through which the data flow
In simple words: Streams act like pipes or pathways that allow information to travel from one place to another within a computer program.

Exam Tip: Remember that streams define a flow, not necessarily a bidirectional one (input vs. output streams), and multiple streams can be open simultaneously.

 

5) Which of the following is used as a separator between fields of a record ?
(a) Path
(b) Delimiter
(c) Variable
(d) Space
Answer: (b) Delimiter
In simple words: A delimiter is a special character, like a comma or a tab, that helps to separate different pieces of information within a record.

Exam Tip: Understand that delimiters are essential for parsing and reading structured data, allowing programs to correctly identify individual fields within a record.

 

6) Scanner class can be used to performing which of the following operations ?
(a) Accept input from the keyboard
(b) Read from the file
(c) Parse a string separated by delimiters
(d) All of the options
Answer: (d) All of the options
In simple words: The Scanner class is a versatile tool in Java that can take input from the keyboard, read data from files, and break apart text using special characters.

Exam Tip: The Scanner class is highly flexible. Recognize its ability to handle various input sources and its tokenizing capabilities for structured input.

 

Computer Class 12 GSEB Notes Chapter 11 File Handling

 

Storage Devices Of Computer System

Storage devices of a computer system can be broadly categorized into two types: (1) Volatile storage and (2) Non-volatile storage.

 

(1) Volatile Storage :

• Volatile storage is temporary. Values kept in variables disappear when a computer is shut down.
• A Java program that stores a value in a variable utilizes Random Access Memory (RAM). Besides variables, objects and their references are generally held in RAM.
• Once the program ends or the computer powers off, the data is lost.

 

(2) Non-Volatile Storage :

• Non-volatile storage provides permanent storage. Data is not lost when a computer loses power.
• When a Java program is saved on a disk, it uses permanent storage.
• A computer file is a collection of data kept on a non-volatile device. Files exist on permanent storage devices, such as hard disks, USB drives, optical disks, and compact discs. Data saved in files is often called persistent data.

 

File Class In Java

• The \( \text{java.io.File} \) class wraps information about the properties of a file or a directory.
• The File class can be used to access attributes of files and directories.
• A programmer can create, rename, or delete a file or a directory. The attributes of a file, like its permissions, length, or last modification time, can also be accessed.
• Creating a file object that belongs to the File class does not mean the file or directory actually exists.
• A File object encapsulates a pathname or a reference to a physical file or directory on the hard disk. There are almost 30 methods that can be used to perform various operations on a file or a directory.

 

Constructors Of File Class

• By using the File class, one can create a reference to any file by giving its absolute path in string format or by giving the relative path.
• The File class offers the following constructors to refer to a file or a directory:
  1. File (String path)
  2. File (String directory_path, String file_name)
  3. File (File directory, String file_name)
• One can use an example for the constructors mentioned above.
• In Linux, the "passwd" file located in the "/etc" directory holds information about the users present in the system.
• Suppose one wants to display its attributes; then, its Java file object can be made in three ways:
  1. By specifying the path as:
      \( \text{File fileobj = new File("/etc/passwd");} \)
  2. By specifying the directory and filename as two separate arguments:
      \( \text{File fileobj = new File("/etc", "passwd");} \)
  3. By using the reference to the directory encapsulated in the \( \text{dirobj} \) object:
      \( \text{File dirobj = new File("/etc");} \)
      \( \text{File fileobj = new File(dirobj, "passwd");} \)

 

Methods Of File Class

• The Table below summarizes a few commonly used methods of the File class.

 

Table: Few Widely Used Methods Of File Class

• After creating an object of the File class that references a particular directory, one can use the \( \text{list()} \) method to list all the files present in that directory.
• The program provided in the code listing shows how to list files present in the “/home/Akash/programs/files" directory.
• In the program, a variable has been used to count the number of files and directories for a given directory, an array, \( \text{listOfFiles} \) of the File class, which stores the file objects present in the directory.

 

// List the contents of a Directory
import java.io.File;
public class ListFiles
{
    public static void main(String args[])
    {
        // Provide a Directory Path
        String path = "home/Akash/programs/files";
        String files;
        int countOfFiles;
        try
        {
            File folder = new File(path);
            //Store the list of files in an array of Files [] objects
            File[] listOfFiles = folder.listFiles();
            // count the number of files in the folder
            countOfFiles = listOfFiles.length;
            System.out.print("List of files in the Directory :");
            System.out.println(folder.getAbsolutePath());
            //Iterate to display the name of each file
            for(int i=0; i<countOfFiles; i++)
            {
                if (listOfFiles[i].isFile())
                {
                    files=listOfFiles[i].getName();
                    System.out.println(files);
                }
            }
        }
        catch (Exception eobj)
        {
            System.out.println(eobj);
        }
    }
}

Code Listing: Program To List Files In A Given Directory

 

Terminal
File Edit View Search Terminal Help
$ javac ListFiles.java
$ java ListFiles
List of files in the directory: /home/Akash/programs/files
ScannerFileDemo.class
MyfileOperations.class
BinaryFileDemo.java
FileReaderDemo.java
Charfile1.txt
FileReaderDemo.class
FileWriterDemo.class
FileExceptions.class

Figure: Output Of Code Listing

• Note: The code above lists files and directories found in the "/home/Akash/programs/files" directory.

 

Character Stream Classes

• Character stream classes are a set of classes available in the \( \text{java.io} \) package. They are used to read and write 16-bit Unicode characters.
• Character stream classes are further divided into Reader and Writer classes.
• Reader classes are designed to read characters from files. Writer classes are designed to write characters into a file.
• The figure below illustrates the hierarchy of Character Stream Classes.

 

Figure: Hierarchy Of Character Stream Classes

• As depicted in the figure, the \( \text{java.io.Reader} \) class and \( \text{java.io.Writer} \) class are inherited from the Object class.
• They are abstract classes (meaning classes that cannot be directly instantiated to create an object) and come with a set of methods that their subclasses must implement.
• \( \text{InputStreamReader} \) and \( \text{BufferedReader} \) are subclasses of the \( \text{Reader} \) Class.
• The \( \text{FileReader} \) class is a subclass of the \( \text{InputStreamReader} \) class.
• Similarly, \( \text{OutputStreamWriter} \), \( \text{BufferedWriter} \), and \( \text{PrintWriter} \) are subclasses of the \( \text{Writer} \) class.
• The \( \text{FileWriter} \) class is a subclass of the \( \text{OutputStreamWriter} \) class.
• A detailed explanation of methods and constructors can be found in the online Java documentation at \( \text{http://docs.oracle.com/javase/6/docs/api} \).

 

Writer Classes

• The Writer class is the base class for writing a character stream. The abstract Writer class defines the functionality available for all character output streams.
• In the programs presented here, the \( \text{FileWriter} \) class is used to perform write operations.
• The methods of the Writer class throw \( \text{IOException} \) if a failed I/O operation occurs.
• \( \text{IOException} \) is a checked exception, so it must be handled; otherwise, a compiling error will occur. The table lists a few methods of the Writer class; these methods are utilized by its subclasses.

 

• The \( \text{OutputStreamWriter} \) class extends \( \text{Writer} \) class. It converts a stream of characters into a stream of bytes.
• The \( \text{FileWriter} \) class extends \( \text{OutputStreamWriter} \) and outputs characters to a file.
• Some of its constructors are:
  \( \text{FileWriter (String filepath) throws IOException} \)
  \( \text{FileWriter (File fileobj) throws IOException} \)
  \( \text{FileWriter (String filepath, Boolean append) throws IOException} \)
• In the constructors above, the parameter \( \text{filepath} \) is the full pathname of a file, and \( \text{fileobj} \) is a File class object that describes the file.
• In the last constructor, if \( \text{append} \) is true, characters are added to the end of the file; otherwise, the existing contents of the file are overwritten.
• For example, an object of \( \text{FileWriter} \) can be created as shown below:
  \( \text{FileWriter fwobject = new FileWriter ("/java/files/Charfile1.txt");} \)
• Below is an example that demonstrates how to write to a file. Assume that the files are saved in the working directory.
• The code listing illustrates how to create a file “Charfile1.txt” that does not yet exist.
• Furthermore, one can write a few lines into that file using the \( \text{write ()} \) method.
• Methods like \( \text{write()} \) and \( \text{close()} \) used in this program are inherited from the Writer class.
• The output of the code listing is shown in the figure; after executing the program, one can use the \( \text{cat} \) command to display the contents within the newly created file "Charfile1.txt".

 

//Write to a file using character stream
import java.io.*;
class FileWriterDemo
{
    public static void main(String args[])
    {
        FileWriter fwobject = null;
        try {
            //Create an object of FileWriter
            fwobject = new FileWriter
            ("Charfile1.txt");
            // Write strings to the file
            fwobject.write ("File writing starts...");
            for(int i = 1; i < 11; i++)
                fwobject.write("Line : " + i + "\n");
            fwobject.write("File writing ends...");
        }
        catch (Exception eobj)
        {
            System.out.println(eobj);
        }
        finally
        {
            try {
                //Close the fileWriter
                fwobject.close();
            }
            catch (Exception eobj)
            {
                System.out.println(eobj);
            }
        }
    }
}

Code Listing: Program To Illustrate File Writer Operation

Reader Classes

• Character stream classes are a group of classes available in java.io package. They can be used to read and write 16-bit Unicode characters.
• Character stream classes can be further classified into Reader and Writer classes.
• Reader classes are a group of classes designed to read characters from files. The Writer classes are a group of classes designed to write characters into a file.
• Figure shows the hierarchy of Character Stream Classes.

Table 11.4: Few Methods of FileReader Class

Code Listing: Program to Illustrate File Read Operation

• Figure shows the output of code listing.
• Here it can be noted that the execution of program displays the output on the screen.
• It displays all the contents of the file "Charfilel.txt”.

Byte Stream Classes

• There is a special symbol to identify End of File (EOF).
• While reading from a file, a program must identify that the file has ended.
• However, the program reads from input stream so java read() method returns "-1" to identify the end of data in the stream.

• From the above details, the process of characters using java.io package is understood.
• Most of the real-life applications require numeric calculations like storing the details of inventory in a file and calculating the costs involved or like storing the employee details and their salaries in a file.
• For such kind of processing, java provides a set of binary streams and their associated classes.
• The FileInputStream and FileOutputStream classes in the java.io package, give the ability to read and write from and into files in the disk.
• These classes are the sub-classes of InputStream and OutputStream classes.

(1) FileOutputStream:

• The FileOutputStream is a subclass of OutputStream and is used to write bytes to the file or some output stream.
• To use this class and its methods, first there is a need to create a file, then use the write method derived from the abstract class OutputStream to write byte data into a file.
• Few widely used methods of FileOutputStream classes are shown in table.

Table: Few Methods of FileOutputStream Class

• The constructors of FileOutputStream can accept either a string containing the path to the file location or an object of the File class.
• Few of the constructors normally used are: FileOutputStream (String name) throws FileNotFoundException Or FileOutputStream (File file) throws FileNotFoundException
• Examples of creating instances of FileOutputStream are as shown below: FileOutputStreamfosobject = new FileOutputStream ("/home/Akash/myfile.txt");
• Alternatively the following can also be used: File fobj = new File ("/home/Akash/myfile.txt"); FileOutputStreamfosobject = new FileOutputStream (fobj);

(2) FileInputStream:

• The FileInputStream is a subclass of InputStream and is generally used to read byte data from the files.
• It provides a set of methods to perform write operations over the files as shown in table 11.6.

Table: Few Methods of FileInputStream Class

• Below is a program that uses the above-described classes to perform write and read operations over a file as shown in code listing.

Code Listing: Program to Read and Write Bytes to Binary File

• The program shown in code listing writes a string to a file "Binaryfile.dat".
• Later it creates an object of FileInputStream to read the data from the same file and display it on the screen.
• It must be noted in the above program, typecasting is applied to convert integer to character after a read operation is performed.
• Note: To observe the difference between text file and binary file, open the files created using the programs given in code listing.

Processing Input from Keyboard

• In this section the different ways to input data to a java program through the keyboard is explained.
• A program can get input data from live interaction through keyboard / GUI or it may take input as command line arguments or from the files.

(1) Scanner Class:

• Scanner class belongs to the java.util package.
• It provides various methods to read input from the keyboard or from the file.
• A special feature of this class is that it breaks the input string into tokens (words) using a delimiter (White space is the default delimiter).
• Each token can be of a different type, for example a string like “India-1947” can also be read as "String-int" values.
• Some related constructors and few methods of Scanner class are given below: Scanner (String str) Scanner (InputStream isobject) Scanner (File fobject) throws FileNotFoundException
• A Scanner object can be created from a string, file object or InputStream object.
• For instance, the constructor can be used in the following way to read from a file and keyboard respectively: Scanner fileinput = new Scanner(new File("Students.dat")); Scanner kbinput = new Scanner(System.in);
• Some of the important methods available with the Scanner class are listed in table.

Table: Methods of Scanner Class

• Below is a program that reads two numbers interactively from the user and displays the addition of those two numbers.
• Code Listing shows the program:

Code Listing: Program to Add Two Numbers

• The code listing has created an object of Scanner class.
• The constructor of Scanner class accepts “System.in" as an argument so that it reads from the standard input (keyboard).
• Both the numbers are scanned as integer numbers using the nextInt() method of the Scanner class.
• Figure shows the output of the program.

Format and Data of the File Students.data:

• Using this, a program can be written as shown in code listing, which reads the data of each student and performs operations like calculating the total marks and displaying them on the output.