Java - FileOutputStream Class

---

---

Introduction

The Java.io.FileOutputStream class is an output stream for writing data to a File or to a FileDescriptor. Following are the important points about FileOutputStream −

• This class is meant for writing streams of raw bytes such as image data.

• For writing streams of characters, use FileWriter.

Class declaration

Following is the declaration for Java.io.FileOutputStream class −

public class FileOutputStream
   extends OutputStream

Class constructors

Class methods

Methods inherited

This class inherits methods from the following classes −

• Java.io.OutputStream
• Java.io.Object

Example - Closing FileOutputStream After Writing

The following example shows the usage of Java FileOutputStream close() method. This example demonstrates how to manually close a FileOutputStream after writing data to a file.

FileOutputStreamDemo.java

package com.tutorialspoint;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
   public static void main(String[] args) {
      FileOutputStream fos = null;
      try {
         // Open a file output stream
         fos = new FileOutputStream("output.txt");

         // Write some data to the file
         String data = "Hello, World!";
         fos.write(data.getBytes());

         System.out.println("Data written successfully.");

      } catch (IOException e) {
         e.printStackTrace();
      } finally {
         // Close the FileOutputStream in the finally block to ensure closure
         try {
            if (fos != null) {
               fos.close();
               System.out.println("FileOutputStream closed successfully.");
            }
         } catch (IOException e) {
            e.printStackTrace();
         }
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

Data written successfully.
FileOutputStream closed successfully.

Explanation

• A FileOutputStream is created for "output.txt".

• The string "Hello, World!" is converted into bytes and written to the file.

• The close() method is called inside a finally block to ensure that the file is always closed, even if an exception occurs.

• Checking if (fos != null) prevents a NullPointerException in case the file wasn't successfully opened.

Example - Using finalize() to Close a FileOutputStream

The following example shows the usage of Java FileOutputStream finalize() method.

FileOutputStreamDemo.java

package com.tutorialspoint;

import java.io.FileOutputStream;
import java.io.IOException;

public class FileOutputStreamDemo {
   static class CustomFileOutputStream extends FileOutputStream {
      public CustomFileOutputStream(String fileName) throws IOException {
         super(fileName);
      }

      @Override
      protected void finalize() throws Throwable {
         System.out.println("Finalize method called. Closing FileOutputStream.");
         this.close(); // Explicitly closing the file output stream
         super.finalize();
      }
   }

   public static void main(String[] args) throws IOException {
      CustomFileOutputStream fos = new CustomFileOutputStream("output.txt");
      fos.write("Hello, World!".getBytes());

      // Making object eligible for garbage collection
      fos = null;

      // Requesting garbage collection
      System.gc();

      System.out.println("Garbage Collection Requested.");
   }
}

Output

Let us compile and run the above program, this will produce the following result−

Garbage Collection Requested.
Finalize method called. Closing FileOutputStream.

Explanation

• A custom class CustomFileOutputStream extends FileOutputStream and overrides finalize().

• In finalize(), we print a message and explicitly close the file stream.

• The fos object is set to null, making it eligible for garbage collection.

• System.gc() requests garbage collection (though execution is not guaranteed immediately).

• When garbage collection occurs, finalize() gets called, ensuring the file stream is closed.

Example - Writing Data to a File Using FileChannel

The following example shows the usage of Java FileOutputStream getChannel() method.

FileOutputStreamDemo.java

package com.tutorialspoint;

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileOutputStreamDemo {
   public static void main(String[] args) {
      try (FileOutputStream fos = new FileOutputStream("output.txt")) {
         // Get FileChannel from FileOutputStream
         FileChannel fileChannel = fos.getChannel();

         // Create a ByteBuffer with data
         ByteBuffer buffer = ByteBuffer.allocate(64);
         buffer.put("Hello, FileChannel!".getBytes());

         // Flip the buffer to prepare for writing
         buffer.flip();

         // Write buffer contents to the file
         fileChannel.write(buffer);

         System.out.println("Data written to file using FileChannel.");
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

Let us compile and run the above program, this will produce the following result−

Data written to file using FileChannel.

Explanation

• A FileOutputStream object is created for output.txt.

• The getChannel() method is used to get the FileChannel.

• A ByteBuffer is created, filled with data, and flipped to prepare for writing.

• The buffer is written to the file using fileChannel.write(buffer).

• The try-with-resources statement ensures the file stream is closed properly.