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.
Check out our free courses to get an edge over the competition.
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.
Check out upGrad’s Advanced Certification in Cyber Security
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?
Explore our Popular Software Engineering Courses
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.
Check out upGrad’s Advanced Certification in Cloud Computing
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.
In-Demand Software Development Skills
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.”
Explore Our Software Development Free Courses
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.
