Programs

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

Learn Software Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

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.

How to read and write to files in Java?

An object of class InputStream represents a source of data from which bytes can be read, and an object of class OutputStream represents a destination to which bytes can be written. Such objects are used with various classes of the java.io package to read and write files, to read and write data from sockets, and to carry out a variety of other input and output operations.

What are the different file handling libraries in Java?

There are several file handling libraries provided in java. Each one has its own purpose and usage. The java.io package defines the basic file handling classes. So we can say it's the most general purpose file handling library. The java.nio package, also known as the New Input/Output package, is mostly used for high-throughput, low-latency, and low-bandwidth data transfer. It is secure, lightweight, and platform independent. This package extends the java.io package by adding channel-based APIs. Also, the java.nio.file package is for the programming interface to file systems. A file system is a hierarchical organization of data, independent of the physical medium, within which information is stored. A file system enables file sharing and inter-process communication between applications. Also, the java.nio.file.attribute package is for the classes and interfaces for the file system attributes.

What are the applications of file handling in Java?

File handling is one of the many interesting and valuable Java Programming topics. It is vital for Java programmers to know how to create, open, read, write, append and delete a file in Java. This helps programmers to manipulate data in a file. There are many operations that can be performed on a file, such as find out the length of the file, reading the content of a file, determining if the file is writeable and so on.

Want to share this article?

Land on Your Dream Job

Leave a comment

Your email address will not be published. Required fields are marked *

Our Popular Software Engineering Courses

Get Free Consultation

Leave a comment

Your email address will not be published. Required fields are marked *

×
Let’s do it!
No, thanks.