0 0
WP Ad Inserter plugin
Read Time:5 Minute, 42 Second

Table of Contents

The createNewFile() function in Java can create a file. This method produces a boolean value: true if the file was completed successfully, false if it already exists. As you can see, the procedure is encased in a try…catch block. It is required because an IOException is thrown if an error occurs. For example, if the file cannot be created for any reason.

import java.io.File;
import java.io.IOException; public class CreateFile { public static void main(String[] args) { try { File newObj = new File("codeunderscored.txt"); if (newObj .createNewFile()) { System.out.println("File created: " + newObj.getName()); } else { System.out.println("File already exists."); } } catch (IOException e) { System.out.println("An error occurred."); e.printStackTrace(); } } }

To create a file in a particular directory (which requires permission), specify the file’s path and escape the “” character with double backslashes (for Windows). On Mac and Linux, type the route, such as /Users/name/codeunderscored .txt.

import java.io.File;
import java.io.IOException; public class CreateFileDir { public static void main(String[] args) { try { File newObj = new File("Users/Code\codeunderscored.txt"); if (newObj .createNewFile()) { System.out.println(" Created file: " + newObj.getName()); System.out.println("Absolute path: " + newObj.getAbsolutePath()); } else { System.out.println("File is already there."); } } catch (IOException e) { System.out.println("An error occurred."); e.printStackTrace(); } } }

How to Write to a file

The FileWriter class and its write() method are used in the following example to write some text to the file we created earlier. It’s important to remember that once you’ve finished writing to the file, you should shut it with the close() method:

import java.io.FileWriter;
import java.io.IOException; public class WriteToFile { public static void main(String[] args) { try { FileWriter newWriter = new FileWriter("codeunderscored .txt"); newWriter.write("Writing to files in Java is easy peasy!"); newWriter.close(); System.out.println("Completed writing to the file."); } catch (IOException e) { System.out.println("An error occurred."); e.printStackTrace(); } } }

Using BufferedWriter Class

BufferedWriter is a class that allows you to write buffered text. It’s used to create a character-output stream from the text. Characters, strings, and arrays can all be written with it. It has a default buffer size; however, it can be changed to huge buffer size. If no prompt output is required, it is preferable to encapsulate this class with any writer class for writing data to a file.

// Program for writing into a File using BufferedWriter Class // Importing java input output libraries import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException; // Main class
public class BufferedWriterClass { public static void main(String[] args) { // Assigning the file content as input to illustrate String text = "Welcome to Codeunderscored "; // Try block to check for exceptions try { // Create a BufferedWriter object BufferedWriter bfWriter = new BufferedWriter(new FileWriter( "/Users/Code/Desktop/underscored.docx")); // Writing text to the file bfWriter.write(text); // Printing file contents System.out.print(text); // Display message showcasing program execution success System.out.print( "content added to file successfully"); // Closing the BufferedWriter object bfWriter.close(); } // Catch block for handling exceptions that occur catch (IOException e) { // Printing the exception message on the console System.out.print(e.getMessage()); } }

Using the FileOutputStream class

The BufferedWriter class is used to write to a file in this example. However, because this class has a big buffer size, it can write massive amounts of data into the file. It also necessitates the creation of a BufferedWriter object, such as FileWriter, to write content into the file.


It’s used to save unprocessed stream data to a file. Only text can be written to a file using the FileWriter and BufferedWriter classes, but binary data can be written using the FileOutputStream class.

The following example shows how to use the FileOutputStream class to write data to a file. It also necessitates the creation of a class object with the filename to write data to a file. The content of the string is transformed into a byte array, which is then written to the file using the write() method.

// Program for Writing to a File using the FileOutputStream Class import java.io.FileOutputStream;
import java.io.IOException; public class WriteUsingFileOutputStream { public static void main(String[] args) { // Assigning the file contents String fileContent = "Codeunderscored extravaganza "; FileOutputStream outputStream = null; // Try block to check if exception occurs try { // Creating an object of the FileOutputStream outputStream = new FileOutputStream("underscored.txt"); // Storing byte contents from the string byte[] strToBytes = fileContent.getBytes(); // Writing directly into the given file outputStream.write(strToBytes); // Printing the success message is optional System.out.print( "Content added to File successfully."); } // Catch block handling the exceptions catch (IOException e) { // Showing the exception/s System.out.print(e.getMessage()); } // use of the finally keyword with the try-catch block – to execute irregardless of the // exception finally { // object closure if (outputStream != null) { // Second try catch block enforces file closure // even if an error happens try { // file connections closure // when no exception has happen outputStream.close(); } catch (IOException e) { // shows exceptions that are encountered System.out.print(e.getMessage()); } } } }

The writeString() function

Version 11 of Java supports this approach. Four parameters can be passed to this method. The file location, character sequence, charset, and options are all of these. The first two parameters are required for this method to write to a file. It saves the characters as the file’s content. It returns the path to the file and can throw four different types of exceptions. When the file’s content is short, it’s best to use it.

It demonstrates how to put data into a file using the writeString() function from the Files class. Another class, Path, is used to associate the filename with the destination path for the content.

The readString() function of the Files class reads the content of any existing file. The code then uses the latter to ensure that the text is appropriately written in the file.


// Program for Writing Into a File using the writeString() Method import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path; // Main class
public class WriteStringClass { public static void main(String[] args) throws IOException { //file content assigning String text = "Codeunderscored extravaganza!"; // definition of the file' name Path fileName = Path.of( "/Users/Code/Desktop/undercored.docx"); // Writing into the file Files.writeString(fileName, text); // Read file contents String fileContent = Files.readString(fileName); // Printing the files' content System.out.println(fileContent); }


The Java FileWriter class is used to write character-oriented data to a file. It is a character-oriented class since it is utilized in java file handling. There are numerous ways to write to a file in Java, as there are numerous classes and methods that can accomplish this. They include the writeString() function, FileWriterclass, BufferedWriter class and the FileOutputStream.

Source: https://www.codeunderscored.com/writing-files-in-java-with-examples/

C# Tip: Exception handling with WHEN clause Previous post C# Tip: Exception handling with WHEN clause
Model Formsets in Django Next post Model Formsets in Django

Leave a Reply

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.