Overview
In this tutorial, we are going to explain the various ways of How to write to a file in Java with the illustrative examples.
Java write to file line by line is often needed in our day to day projects for creating files through java. There are various classes present in Java which can be used for write to file line by line.
Let’s look at them :
Java write to file line by line using FileOutputStream class
FileOutputStream class is an output stream used for writing data to a File or FileDescriptor. FileOutputStream class is used to write streams of raw bytes such as image data. This class is good to use with bytes of data which cannot be represented as text such as excel document, PDF files, image files etc.
FileOutputStream class is part of the java.io package and it is a subclass of OutputStream
class.


Example : Write to file line by line using FileOutputStream class
// Java Program for Write to file line by line using FileOutputStream class import java.io.File; import java.io.FileOutputStream; public class ExampleJavaFileWrite { public static void main(String[] args) { //Declaring reference of File class File file = null; //Declaring reference of FileOutputStream class FileOutputStream fileOutStream = null; String data = "TechBlogStation"; try { file = new File("D:/TBS/file.txt"); //Creating Object of FileOutputStream class fileOutStream = new FileOutputStream(file); //In case file does not exists, Create the file if (!file.exists()) { file.createNewFile(); } //fetching the bytes from data String byte[] b = data.getBytes(); //Writing to the file fileOutStream.write(b); //Flushing the stream fileOutStream.flush(); //Closing the stream fileOutStream.close(); System.out.println("File writing done."); } //Handing Exception catch (Exception e) { e.printStackTrace(); } finally { try { if (fileOutStream != null) { fileOutStream.close(); } } catch (Exception e) { e.printStackTrace(); } } } }
Java write to file line by line using FileWriter class
FileWriter class creates a writer which can be used to write to a file line by line. FileWriter class is part of the java.io package and it is a subclass of Writer class.


FileWriter creation is not dependent on whether file exists or not . In case file does not exist, FileWriter class will create the file before opening it for output at the time of object creation. In the case , where you are attempting to open a read-only file , an IO Exception will be thrown.


Example : Write to file line by line using FileWriter class
// Java Program for Write to file line by line using FileWriter class import java.io.File; import java.io.FileWriter; public class ExampleJavaFileWrite { public static void main(String[] args) { //Declaring reference of File class File file = null; //Declaring reference of FileWriter class FileWriter filewriter = null; String data = "TechBlogStation"; try { file = new File("D:/TBS/file.txt"); //Creating Object of FileWriter class filewriter = new FileWriter(file); //Writing to the file filewriter.write(data); //Closing the stream filewriter.close(); System.out.println("File writing done."); } //Handing Exception catch (Exception e) { e.printStackTrace(); } finally { try { if (filewriter != null) { filewriter.close(); } } catch (Exception e) { e.printStackTrace(); } } } }
Java write to file line by line using PrintWriter class
PrintWriter is a character oriented version of PrintStream class. Java’s PrintWriter object supports both the print() and println() method for all types even including object. If the calling argument is not a simple type, the printwriter will call the object’s toString() method and then print out the output.
PrintWriter class is part of the java.io package and it is a subclass of Writer class.


Example : Write to file line by line using PrintWriter class
// Java Program for Write to file line by line using PrintWriter class import java.io.File; import java.io.PrintWriter; import java.io.FileWriter; public class ExampleJavaFileWrite { public static void main(String[] args) { //Declaring reference of File class File file = null; PrintWriter pw = null; try { //Creating object of PrintWriter class pw = new PrintWriter(new FileWriter("file.txt")); String data = "TechBlogStation"; //Writing to the file pw.write(data); //Closing the stream pw.close(); System.out.println("File writing done."); } //Handing Exception catch (Exception e) { e.printStackTrace(); } finally { try { if (pw != null) { pw.close(); } } catch (Exception e) { e.printStackTrace(); } } } }
OutputStreamWriter class
An OutputStreamWriter acts as a bridge from character streams to byte streams: Characters written to it will be encoded into bytes using a charset
OutputStreamWriter class is part of the java.io package and it is a subclass of Writer class.


OutputStreamWriter class Example:
// Java Program for Write to file line by line using OutputStreamWriter class import java.io.File; import java.io.FileOutputStream; import java.io.OutputStreamWriter; public class ExampleJavaFileWrite { public static void main(String[] args) { //Declaring reference of File class File file = null; //Declaring reference of FileOutputStream class FileOutputStream fos = null; //Declaring reference of OutputStreamWriter class OutputStreamWriter osw = null; try { file = new File("result.txt"); //Creating object of FileOutputStream class fos = new FileOutputStream(file); //Creating object of OutputStreamWriter class osw = new OutputStreamWriter(fos); String data = "TechBlogStation"; //Writing to the file osw.write(data); //Closing the stream osw.close(); System.out.println("File writing done."); } //Handing Exception catch (Exception e) { e.printStackTrace(); } finally { try { if (osw != null) { osw.close(); } } catch (Exception e) { e.printStackTrace(); } } } }
Java write to file line by line using BufferedWriter
It will write text to a character-output stream, buffering characters to provide for the effective writing of single characters and strings.
A BufferedWriter is a Writer that adds a flush method which can be used to ensure that the data buffers are physically written to the actual output stream. BufferedWriter can increase the performance by reducing the number of times data is written to output stream.
BufferedWriter class is part of the java.io package and it is a subclass of Writer class.


Example : Write to file line by line using BufferedWriter
// Java Program for Write to file line by line using BufferedWriter class import java.io.File; import java.io.FileWriter; import java.io.BufferedWriter; public class ExampleJavaFileWrite { public static void main(String[] args) { //Declaring reference of File class File file = null; //Declaring reference of BufferedWriter class BufferedWriter bw = null; //Declaring reference of FileWriter class FileWriter fw = null; try { file = new File("result.txt"); //Creating object of FileWriter class fw = new FileWriter(file); //Creating object of BufferedWriter class bw = new BufferedWriter(fw); String data = "TechBlogStation"; //Writing to the file bw.write(data); //Closing the stream bw.close(); System.out.println("File writing done..."); } //Handing Exception catch (Exception e) { e.printStackTrace(); } finally { try { if (bw != null) { bw.close(); } } catch (Exception e) { e.printStackTrace(); } } } }
You can download the code for above examples from my github repository.
Conclusion


We have learnt about various ways of writing file line by line in Java with the Examples. Any of the way can be used as per requirement to write to file. Now it will be easy to write a program for you using any of these ways.