File Handling in Java: How to Work with Java Files?

Java is a widely popular programming language. Besides robust architecture and components, one of the most significant reasons behind its success and popularity is its support for numerous functionalities. File handling in Java is one such functionality that allows us to work with files. Today, we will be learning about various operations we can perform with the file concepts in Java.

What is Java File Handling?

As mentioned, file handling in Java allows you to work with files. It is a Java functionality defined in the File class of the Java.io package. The io in Java.io package stands for Input and Output. You will find all the classes you will ever need to perform any input or output operations in the Java.io package.

You can access and use this File class to perform various functions by creating an object and providing the file or directory name. The syntax to create an object and use the File class is:

import java.io.File;

File obj = new File(“name.txt”);

As seen in the above syntax, you first need to import the File class from the Java.io package. Once imported, all you need to do is create an object and specify the file or directory name you want to work with. To mention the directory name in a Windows OS, you have to use “\\.” For instance, you have to use “C:\\Users\\MyFolder\\MySubFolder” and not “C:\Users|MyFolder|MySubFolder.” However, for other operating systems such as Linux, you can use the single \ as usual.

All the I/O (Input/Output) operations of the file concepts in Java are done with the help of a stream. Let’s delve deep into what is a stream, and how are these operations performed with it?

What is the Concept of Streams in Java?

In simpler terms, a stream is a series of data. There are two types of stream, which are:

  • Byte stream: This type of stream works with byte data. The I/O operations are performed with a byte stream when you read or write data in the byte (8-bit) format.
  • Character stream: This type of stream works with character sequence. The I/O operations are performed with a character stream when you are reading or writing data using characters.

Checkout: Top Java Projects on GitHub

What are the Different Methods Available for File Handling in Java?

The File class provides various predefined methods to help you perform all the I/O operations by merely calling them. The below table shows all the methods, along with the actions they perform.

Method Type Description
canRead() Boolean It checks whether you can read the file or not.
canWrite() Boolean It tests whether you can write into the file or not.
createNewFile() Boolean This will create a new empty file.
delete() Boolean This method will delete the specified file.
exists() Boolean It checks if the mentioned file exists.
getName() String Returns file’s name.
getAbsolutePath() String Returns the file’s absolute pathname.
length() Long It returns the file’s size in bytes.
list() String[] Returns a list of file names present in the directory.
mkdir() Boolean This method will create a new directory.

How to Perform Different Java File Handling Operations?

Since you know about the different methods available in the File class, it’s time to use them to perform various Java file handling operations. To begin with, you can complete the following actions on a file.

  • Create a new file.
  • Get file information.
  • Write into a file.
  • Read from a file.
  • Delete a file.

We will be going through an example to perform each of these operations. In the first example, we will create a new file and then use the same file to perform other tasks.

Creating a File

You can create a file with the createNewFile() method. Executing the method will return either true or false. If the file is created successfully, it will return a true. On the other hand, if the file already exists, it will return a false.

It is always advised to use this method within a try and catch block as it can throw an exception if the file is not created successfully. You can learn more about it in our guide on exception handling in Java. See the below example that uses the createNewFile() method to create a new empty file.

import java.io.File;  // Importing the File class

import java.io.IOException;  // Importing the IOException class for handling errors

public class CreateFileExample{

    public static void main(String[] args){

        try{

            File obj = new File(“newFile.txt”);

            if(obj.createNewFile()){ // if it returns true, i.e., successfully created

                System.out.println(“The ile is created successfully:” + obj.getName());

            }

            else{ // if it returns false, i.e., file already exists

                System.out.println(“File already exists”);

            }

        }

        catch (IOException e){ // to catch exceptions if any error occurs

            System.out.println(“Error occurred”);

            e.printStackTrace();

        }

    }

}

Output:

The file is created successfully: newFile.txt

Getting File Information

You can use various methods defined in the File class to access the file’s different information, such as name, length, absolute path, readable, and more. Some of the methods to get file information are used in the below example.

import java.io.File;

public class AccessInfoExample{

    public static void main(String[] args){

        // Creating an object

        File obj = new File(“newFile.txt”);

        if(obj.exists()){

            // Getting file name

            System.out.println(“The name of the file is:” + obj.getName());

            // Getting absolute path

            System.out.println(“The absolute path of the file is:” + obj.getAbsolutePath());   

            // Checking if file is writable

            System.out.println(“Is the file writable?” + obj.canWrite());  

            // Checking if file is readable

            System.out.println(“Is the file readable?” + obj.canRead());  

            // Getting the length in bytes

            // It will show 0 as we haven’t written anything in our file yet

            System.out.println(“File size in bytes:” + obj.length());  

        }

        else{

            System.out.println(“File named” + obj.getName() + “does not exist.”);

        }

    }

}

Output:

The name of the file is: newFile.txt

The absolute path of the file is: D:JavaProgramming:newFile.txt

Is the file writable? true

Is the file readable? true

File size in bytes: 0

The above example’s output may vary depending on the file’s name, the path where you saved it, and the size. If the specified file does not exist, it will show “File named newFile.txt does not exist.”

Writing Into a File

To write bytes data, use the FileOutputStream class, and for characters, use the FileWriter class. In the below example, we will use the FileWriter class and its predefined write() method to write something inside our “newFile.”

One thing to note before starting with the example is that whenever you open a file for writing, you need to close it with the close() method. Closing the file will allow you to retrieve the resources allocated by the Java compiler to write in a file. Let’s have a look at how to do it in the example.

import java.io.FileWriter;   // Importing the FileWriter class

import java.io.IOException;  // Importing the IOException class for handling errors

public class WriteExample{

    public static void main(String[] args){

        try{

            FileWriter obj = new FileWriter(“newFile.txt”);

            obj.write(“This will be written in the newFile.txt file!”);

            obj.close(); // Closing the file

            System.out.println(“We have successfully written in the file and closed it.”);

        }

        catch(IOException e){

            System.out.println(“Error occurred.”);

            e.printStackTrace();

        }

    }

}

Output:

We have successfully written in the file and closed it.

Reading From a File

You can use FileInputStream to read bytes data and FileReader to read characters data from a file. Alternatively, you can also use the Scanner class to read from a file. Since we have already used the FileWriter to write data, we will use the Scanner class to read data in this example. Like while writing, closing the opened file is necessary while reading as well.

import java.io.File;  // Importing the File class

import java.io.FileNotFoundException;  // Importing the class for handling errors

import java.util.Scanner; // Importing the Scanner class for reading text files

public class ReadExample{

    public static void main(String[] args){

        try{

            File obj = new File(“newFile.txt”);

            Scanner robj = new Scanner(obj);

            while (robj.hasNextLine()){

                String dataInfo = robj.nextLine();

                System.out.println(dataInfo);

            }

            robj.close();

        }

        catch(FileNotFoundException e){

            System.out.println(“Error occurred.”);

            e.printStackTrace();

        }

    }

}

Output:

This will be written in the newFile.txt file!

Deleting a File

You can delete a file by using the delete() method of the File class. You can also delete an entire folder if it is empty. Let’s delete our “newFile.txt” file in the below example.

import java.io.File;  // Import the File class

public class DeleteExample{

    public static void main(String[] args){ 

        File obj = new File(“newFile.txt”); 

        if(obj.delete()){ 

            System.out.println(“The file named” + obj.getName() + “is deleted successfully.”);

        }

        else{

            System.out.println(“File not deleted.”);

        } 

    } 

}

Output:

The file named newFile.txt is deleted successfully.

Also Read: Java Project Ideas & Topics

Conclusion

In this post, you learned everything about file handling in Java. Java provides various such functionalities, which makes it one of the most popular programming languages worldwide. Hence, it is no surprise that Java developers’ salary in India is very high. If you want to become a Java developer and get a high salary package, upGrad’s free Java online course is apt for you.

The course is a part of the upStart program, a priceless upskilling initiative. Once you are done with the free course and get the certification, you can further opt for upGrad’s PG Certification in Full-Stack Development. You get 400+ hours of learning material with hands-on experience through projects. Take the course and excel in the field of software development with Java programming concepts.

Land on Your Dream Job

UPGRAD AND IIIT-BANGALORE'S PG DIPLOMA IN SOFTWARE DEVELOPMENT
APPLY NOW

Leave a comment

Your email address will not be published.

×