Java - BufferedOutputStream write(byte[], int, int) method

---

---

Description

The Java BufferedOutputStream write(byte[], int, int) method writes to the stream starting at offset off of len bytes from the specified byte array b. For the length as large as this stream's buffer will flush the buffer and write the bytes directly to the output stream.

Declaration

Following is the declaration for java.io.BufferedOutputStream.write(byte[] b, int off, int len) method.

public void write(byte[] b, int off, int len)

Parameters

• b − byte array as source data

• off − The start offset in the source

• len − number of bytes to write to the stream

Return Value

This method does not return any value.

Exception

IOException − If an I/O error occurs.

Example - Writing an integer to OutputStream

The following example shows the usage of Java BufferedOutputStream write(byte[] b, int off, int len) method.

BufferedOutputStreamDemo.java

package com.tutorialspoint;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo {
   public static void main(String[] args) throws Exception {
      BufferedOutputStream bos = null;
      ByteArrayOutputStream baos = null;
      try {
         // create new output streams.
         baos = new ByteArrayOutputStream();
         bos = new BufferedOutputStream(baos);

         // assign values to the byte array 
         byte[] bytes = {1, 2, 3, 4, 5};

         // write byte array to the output stream
         bos.write(bytes, 0, 5);

         // flush the bytes to be written out to baos
         bos.flush();

         for (byte b:baos.toByteArray()) {
            
            // prints byte
            System.out.print(b);
         }
      } catch(IOException e) {
         // if any IOError occurs
         e.printStackTrace();
      } finally {
         // releases any system resources associated with the stream
         if(baos!=null)
            baos.close();
         if(bos!=null)
            bos.close();
      }
   }
}

Output

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

12345

Example - Writing a Subset of a Byte Array to a File

The following example shows the usage of Java BufferedOutputStream write(byte[] b, int off, int len) method.

BufferedOutputStreamDemo.java

package com.tutorialspoint;

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

public class BufferedOutputStreamDemo {
   public static void main(String[] args) {
      byte[] data = "Hello, this is an example of write!".getBytes();

      try (BufferedOutputStream bos = new BufferedOutputStream(
         new FileOutputStream("example.txt"))) {
         // Write only a portion of the byte array (starting at offset 7, 16 bytes)
         bos.write(data, 7, 16);
         bos.flush(); // Ensure all data is written
         System.out.println("Subset of byte array written to example.txt.");
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

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

Characters written to example.txt

Explanation

• Data Source− A byte array is created from the string "Hello, this is an example of write!".

• Using write(byte[] b, int off, int len)−

  • The method writes 16 bytes starting from offset 7 in the byte array.

  • This corresponds to the substring "this is an exam".

• Output−

  • The file example.txt will contain−

  • this is an exam

Example - Writing a Subset of a Byte Array to a ByteArrayOutputStream

The following example shows the usage of Java BufferedOutputStream write(int b) method.

BufferedOutputStreamDemo.java

package com.tutorialspoint;

import java.io.BufferedOutputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo {
   public static void main(String[] args) {
      byte[] data = "Java BufferedOutputStream example.".getBytes();

      try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
         BufferedOutputStream bos = new BufferedOutputStream(baos)) {

         // Write part of the byte array (from offset 5, 18 bytes)
         bos.write(data, 5, 18);
         bos.flush(); // Ensure the buffer is flushed to the ByteArrayOutputStream

         // Print the content of the ByteArrayOutputStream
         System.out.println("Content in ByteArrayOutputStream: " + baos.toString());
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

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

Content in ByteArrayOutputStream: BufferedOutputStre

Explanation

• Data Source− A byte array is created from the string "Java BufferedOutputStream example.".

• Using write(byte[] b, int off, int len)−

  • The method writes 18 bytes starting from offset 5 in the byte array.

  • This corresponds to the substring "BufferedOutputStre".

• Output−

  • Content in ByteArrayOutputStream: BufferedOutputStre

Key Points

• Selective Writing−

  • The write(byte[] b, int off, int len) method allows writing a specific portion of the byte array, making it efficient for partial data transfer.

• Usage−

  • Useful for writing portions of large byte arrays to avoid copying or slicing the array.

• Flushing−

  • Always use flush() after writing to ensure that buffered data is immediately written to the output stream.

• Error Handling−

  • If off or len is invalid (e.g., out of bounds), an IndexOutOfBoundsException is thrown. Always ensure the offsets and lengths are valid.