File Handling in Java

Last Updated on October 16, 2023 by Ankit Kochar

File handling is a fundamental aspect of programming, enabling us to interact with and manipulate data stored on our computer’s file system. In Java, a versatile and widely-used programming language, file handling plays a crucial role in various applications, from data storage and retrieval to configuration management and log files. Understanding how to work with files in Java is essential for any developer. This article explores the fundamentals of file handling in Java, from reading and writing files to managing directories and handling exceptions.

What is File Handling in Java?

File handling in Java refers to the process of reading and writing data from and to a file in a Java program. The file can be a text file, an image file, or any other type of data that can be stored in a file. The goal of file handling is to allow a program to access data stored in a file, manipulate it, and write it back to the file.

We can work with files in Java thanks to the File Class. This File Class is part of the java.io package. Create an object of the File class and then specify the name of the file to use it.

Example of File Handling in Java

// Importing File Class
import java.io.File;

class Main {
    public static void main(String[] args)
    {

        // File name specified
        File obj = new File("myPrepBytesfile.txt");
        System.out.println("File Created!");
    }
}

To conduct I/O operations on a file in Java, the concept Stream is used. So, first and foremost, let us become familiar with the concept of Stream in Java.

What is a Stream in Java?

Stream is a concept of Java that pipelines a series of objects to achieve the desired output. A stream is not a data structure; it just accepts input from a collection of I/O.

A stream can be divided into two types: input streams and output streams.

Input Stream

The superclass of all input streams is Java InputStream. The input stream is used to read data from various input devices such as the keyboard, network, and so on. Because InputStream is an abstract class, it is useless by itself. However, subclasses InputStream are used to read data.

The Input Stream class has the following subclasses:

• ByteArrayInputStream
• FileInputStream
• AudioInputStream
• StringBufferInputStream
• FilterInputStream
• ObjectInputStream

Let’s create an InputStream

// Creating an InputStream
InputStream Buddy = new FileInputStream();

Here, FileInputStream is used to create an InputStream.

Methods of Input Stream

The InputStream class in Java provides several methods for reading data, including the following:

• int read(): This method reads the next byte of data from the input stream and returns it as an int in the range 0 to 255.If the stream has reached the end, it returns -1.
• int read(byte[] b): This method reads up to b.length bytes of data from the input stream into an array of bytes. It returns the total number of bytes read into the buffer, or -1 if no more data can be read since the stream has reached its end.
• int read(byte[] b, int off, int len): This method reads up to len bytes of data from the input stream into an array of bytes starting at an offset of off within the buffer. It returns the total amount of bytes read into the buffer, or -1 if there is no further data since the stream has reached its end.
• long skip(long n): This method skips over and discards n bytes of data from the input stream. It returns the number of bytes that were actually skipped.
• int available(): This method returns an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking by the next invocation of a method for this input stream.
• void close(): This method closes the input stream and releases any system resources associated with the stream.

Note: It is a good practice to always close the input stream after you are done with it to release the resources it is holding.

Output Stream

The output stream is used to write data to a variety of output devices such as the display, file, and so on. OutputStream is an abstract superclass that represents an output stream. Because OutputStream is an abstract class, it is useless on its own. Its subclasses, on the other hand, are used to write data.

The Output Stream class has the following subclasses:

• FileOutputStream
• StringBufferOutputStream
• ByteArrayOutputStream
• PrintStream
• ObjectOutputStream
• DataOutputStream

Let’s create an OutputStream

// Creating an OutputStream
OutputStream Buddy = new FileOutputStream();

Here, FileOutputStream is used to create an OutputStream.

Methods of Output Stream

The OutputStream class in Java provides several methods for writing data, including the following:

• void write(int b): This method writes the specified byte to the output stream.
• void write(byte[] b): This method writes b.length bytes from the specified byte array to the output stream.
• void write(byte[] b, int off, int len): This method writes len bytes from the specified byte array starting at an offset of off within the buffer to the output stream.
• void flush(): This method flushes any buffered output bytes to the underlying output device.
• void close(): This method closes the output stream and releases any system resources associated with the stream.

Note: It is a good practice to always close the output stream after you are done with it to release the resources it is holding.

Java File Class Methods

The java.io.File class in Java provides several methods for working with files and directories, including the following:

• boolean exists(): This method returns true if the file or directory specified by the File object exists, and false otherwise.
• boolean isDirectory(): This method returns true if the File object represents a directory, and false otherwise.
• boolean isFile(): This method returns true if the File object represents a regular file, and false otherwise.
• String getName(): This method returns the name of the file or directory specified by the File object.
• String getAbsolutePath(): This method returns the absolute pathname of the file or directory specified by the File object.
• long length(): This method returns the size, in bytes, of the file specified by the File object.
• String[] list(): This method returns an array of strings naming the files and directories in the directory specified by the File object.
• File[] listFiles(): This method returns an array of File objects for the files and directories in the directory specified by the File object.
• boolean createNewFile(): This method creates a new, empty file with the name specified by the File object and returns true if the file was created successfully, and false otherwise.
• boolean delete(): This method deletes the file or directory specified by the File object and returns true if the file or directory was deleted successfully, and false otherwise.
• boolean mkdir(): This method creates a new directory with the name specified by the File object and returns true if the directory was created successfully, and false otherwise.
• boolean mkdirs(): This method creates a new directory with the name specified by the File object, including any necessary but nonexistent parent directories, and returns true if the directory was created successfully, and false otherwise.
• boolean renameTo(File dest): This method renames the file or directory specified by the File object to the file or directory specified by the dest File object and returns true if the file or directory was renamed successfully, and false otherwise.

Let us now become acquainted with the various file operations available in Java.

File Operations in Java

Here are some common file operations in Java:

Create

In Java, the createNewFile() method can be used to create a file. If the file is successfully created, it will return the Boolean value true, else it will return false. The following is an example of how to create a file in Java:

import java.io.File;
import java.io.IOException;

public class Main {
    public static void main(String[] args)
    {

        try {
            File prepObj = new File("myfile.txt");
            if (prepObj.createNewFile()) {
                System.out.println("File created: "
                                + prepObj.getName());
            }
            else {
                System.out.println("File already exists.");
            }
        }
        catch (IOException e) {
            System.out.println("An error has occurred.");
            e.printStackTrace();
        }
    }
}

Output:

An error has occurred.

Read

To read the contents of a file, we’ll use the Scanner class. Here’s an example of how to read the contents of a file in Java:

import java.io.File;
import java.io.FileNotFoundException;
// Import the Scanner class to read content from text files
import java.util.Scanner;

public class Main {
    public static void main(String[] args)
    {
        try {
            File Obj = new File("myfile.txt");
            Scanner Reader = new Scanner(Obj);
            while (Reader.hasNextLine()) {
                String data = Reader.nextLine();
                System.out.println(data);
            }
            Reader.close();
        }
        catch (FileNotFoundException e) {
            System.out.println("An error has occurred.");
            e.printStackTrace();
        }
    }
}

Output:

An error has occurred.

Write

In order to write text to a file, we use the FileOutputStream class and its write() method. The following is an example of how to write text to a file in Java:

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Main {
  public static void main(String[] args) {
    File obj = new File("example.txt");
    String content = "This is a sample file content.";
    try {
      FileOutputStream fos = new FileOutputStream(obj);
      fos.write(content.getBytes());
      System.out.println("Successfully written");
      fos.close();
    } catch (IOException e) {
      System.out.println("Error Encounter");
      e.printStackTrace();
    }
  }
}

Output:

Error Encounter

Delete

We use the delete() method in order to delete a file. Following is an example of how to delete a file in Java:

import java.io.File;

public class Main {
  public static void main(String[] args) {
    File obj = new File("example.txt");
    if (obj.delete()) {
      System.out.println("File deleted successfully.");
    } 
    else {
      System.out.println("File delete failed.");
    }
  }
}

Output:

File delete failed.

Conclusion
In the world of software development, the ability to handle files effectively is a fundamental skill. A robust and comprehensive set of tools and libraries for file handling in Java, making it a versatile language for a wide range of applications. Whether you’re building a simple text editor or a complex data processing system, knowing how to read, write, and manipulate files in Java is a valuable skill.

To summarize, this article has covered the basics of file handling in Java, including file input and output operations, working with directories, error handling, and best practices. Armed with this knowledge, you have the foundation to create powerful applications that interact seamlessly with files and data on your computer.

FAQs on File Handling in Java

Below are some frequently asked questions (FAQs) on file handling in Java:

1. How do I read a text file in Java?
You can read a text file in Java using classes like FileReader and BufferedReader. These classes allow you to open the file, read its contents line by line, and process the data.

2. What is the difference between absolute and relative file paths in Java?
An absolute file path specifies the complete path from the root directory, while a relative file path is specified relative to the current working directory of your Java application.

3. How can I write data to a file in Java?
To write data to a file in Java, you can use classes like FileWriter and BufferedWriter. These classes allow you to open the file for writing and write data to it.

4. What is the best practice for handling exceptions in file operations?
It’s essential to handle exceptions gracefully in file handling. You should use try-catch blocks to catch and handle exceptions like IOException. Additionally, it’s a good practice to close files in a finally block to ensure resources are released properly.

5. Can I work with binary files in Java?
Yes, Java provides classes like FileInputStream and FileOutputStream for reading and writing binary files. You can use these classes to work with files containing non-text data, such as images, audio, and more.

6. How do I list files and directories in a directory using Java?
You can list files and directories in a directory using the list() and listFiles() methods of the File class. These methods return an array of strings or File objects, respectively, representing the contents of the directory.

7. Are there any libraries or frameworks for advanced file handling in Java?
Yes, Java has numerous libraries and frameworks for advanced file handling, such as Apache Commons IO and Java NIO (New I/O). These libraries provide enhanced functionality and performance for various file operations.