Java FileNotFoundException

Introduction to Java FileNotFoundException

Java FileNotFoundException is a type of exception that often occurs while working with File APIs in Java where the path specified for a file for reading or writing purposes in the constructor of classes FileInputStream, FileOutputStream, and RandomAccessFile, either does not exist or inaccessible due to an existing lock or other technical issues. This is a checked exception is a direct subclass of IOException that has been introduced with JDK 1.0. Also, it contains two types of constructors that can be called where one returns an Exception with a null message to display, whereas the other prints the specified message in case the exception occurs.

Syntax:

public class FileNotFoundExceptionextends IOException

• public: The keyword public refers to that the given class is accessible from any class in the project and needs to be inherited to throw an exception.

This class is a direct subclass of IOException, thus inheriting all the class’s methods and variables.

How FileNotFoundException work in Java?

FileNotFoundException is a checked exception is used that occurs when a file path specified for accessing does not exist or is inaccessible. With the checked exception, it means that the java compiler checks at compile time if this exception has been handled or not; otherwise, a compile-time error occurs. Let us see how the exception is thrown at run-time in case it has been handled using try-catch blocks or using throws keyword in its definition at compiler time.

Example:

File fileObj = new File(“C:/JavaPractice.txt”)

Suppose we instantiate a File class object as given above with a path of a file, and that file does not exist. In that case, when the compiler attempts to read or write the file and finds such a situation, it throws an exception and create an instance of FileNotFoundExceptionclass. In case it is not specified which constructor needs to be called, the constructor with no error message is thrown.

Thus the application fails with the below error:

Constructors of Java FileNotFoundException

FileNotFoundException is a subclass of IOException that is very useful to trace if the file specified in the file path exists and even accessible. Thus for using this, one needs to instantiate it, and it is a public class; it can be instantiated from any where in the project. And for creating the instance of the class has 2 types of constructors.

Given below are the two types of constructors:

1. Constructor with no error message

This type of constructor is used to create an instance of FileNotFoundException class where it returns null as its error detail message.

Syntax:

public FileNotFoundException()

Example:

FileNotFoundExceptionexcepObj = new FileNotFoundException()

2. Constructor with an error message

This type of constructor is used to create an instance of FileNotFoundException class where it returns a specified string as its error detail message.

Syntax:

public FileNotFoundException(String s)

Example:

FileNotFoundExceptionexcepObj = new FileNotFoundException(“This is a FileNotFoundException”)

The error message specified can be easily retrieved using the Throwable.getMessage() method since this is one of the superclasses of FileNotFoundException class.

Examples of Java FileNotFoundException

Given below are the examples mentioned:

Example #1

Here we see how an exception is thrown by JVM if one file in inaccessible. In this, the error message displaying in output is one specified by default by JVM.

Code:

//package Proc;
import java.io.Console;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
public class prac1 {
public static void main(String[] args) {
File fileObj = new File("D:/JavaPractice.txt");
FileInputStream fISObj = null;
try{
fISObj = new FileInputStream(fileObj);
while (fISObj.read()!=-1){
System.out.println(fISObj.read());
}
}catch (FileNotFoundException e){
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}
}

Output:

Example #2

In this example, we will use the constructor with a specified error message to display the error when the file does not exist at the given path. We have used the throw keyword to throw the exception.

Code:

//package Proc;
import java.io.Console;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
public class prac1 {
public static void main(String[] args) throws FileNotFoundException,IOException{
File fileObj = new File("D:/JavaPractice.txt");
if(!fileObj.exists()){
throw new FileNotFoundException("This file doesnot exist in the path specified "+fileObj.toString());
}
else {
System.out.println("Welcome, we got into file "+fileObj.toString());
}
}
}

Output:

How to avoid FileNotFoundException?

Getting a FileNotFoundException in an application makes an application inefficient. The first step to avoid this exception is to check if the specified file exists in at the specified path, but still, there might occur a situation in real-time applications that the file is missing or if other processes lock the file to be read to write into it.

Case 1: File is missing

To avoid this, one can use the java.io.File.exists() method to check if the file one attempts to read exist on the path specified or not. Using this, we must make sure if our code is able to handle the FileNotFoundException exception.

Case 2: File is inaccessible

To avoid such cases, one needs to take care if the file we are attempting to read is currently locked by other users writing it. For this we can use canRead() or canWrite() methods of java.io. File class that tells if the specified file is available for reading or writing purposes or not.

Using these 2 precautionary measures, one can easily avoid an attempt by an instance of file class to open a file that can result into a checked exception. This improves the efficiency of an application that includes a program to access files from a specified path.

Conclusion

FileNotFoundException is a type of checked exception that occurs once an attempt is made to the file that either does not exist or not accessible at that moment due to some lock. Since it is a checked exception java compiler ensures it has been handled at compile time. But still, if one needs to avoid it so they can use exist(), canRead() or canWrite() methods present in File class.

Recommended Articles

This is a guide to Java FileNotFoundException. Here we discuss how FileNotFoundException work in Java along with the constructors and programming examples. You may also have a look at the following articles to learn more –

1. Finally in Java
2. Java Directories
3. Exception Handling in Java
4. JSON in Java