Java - SequenceInputStream read(byte[] b,int off,int len) method

Description

The Java SequenceInputStream read(byte[] b,int off,int len) method reads up to len bytes of data from this input stream into an array of bytes. If len is not zero, the method blocks until at least 1 byte of input is available; otherwise, no bytes are read and 0 is returned.

Declaration

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

public int read(byte[] b,int off,int len)

Parameters

• b− The buffer into which the data is read.

• off− The start offset in array b at which the data is written.

• b− The maximum number of bytes read.

Return Value

This method returns the number of bytes read.

Exception

• NullPointerException − If b is null

• IndexOutOfBoundsException − If off is negative, len is negative, or len is greater than b.length - off

• IOException − If an I/O error occurs.

Example - Usage of SequenceInputStream read(byte[] b,int off,int len) method

The following example shows the usage of SequenceInputStream read(byte[] b,int off,int len) method.

SequenceInputStreamDemo.java

package com.tutorialspoint;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.SequenceInputStream;

public class SequenceInputStreamDemo {
   public static void main(String[] args) {

      // create two  new strings with 5 characters each
      String s1 = "Hello";
      String s2 = "World";

      // create 2 input streams
      byte[] b1 = s1.getBytes();
      byte[] b2 = s2.getBytes();
      ByteArrayInputStream is1 = new ByteArrayInputStream(b1);
      ByteArrayInputStream is2 = new ByteArrayInputStream(b2);

      // create a new Sequence Input Stream
      SequenceInputStream sis = new SequenceInputStream(is1, is2);

      // create a new byte array
      byte arr[] = {'1', '2', '3', '4'};
      
      try {
         // read 3 chars and print the number of chars read
         System.out.print("" + sis.read(arr, 0, 3));

         // change line
         System.out.println();

         // close the streams
         sis.close();

      } catch (IOException ex) {
         ex.printStackTrace();
      }
   }
}

Output

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

3

Example - Read part of the data into the middle of a byte array

The following example shows the usage of SequenceInputStream read(byte[] b,int off,int len) method.

SequenceInputStreamDemo.java

package com.tutorialspoint;

import java.io.ByteArrayInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;
import java.util.Arrays;

public class SequenceInputStreamDemo {
   public static void main(String[] args) {
      try {
         ByteArrayInputStream stream1 = new ByteArrayInputStream("Java".getBytes());
         ByteArrayInputStream stream2 = new ByteArrayInputStream("123".getBytes());

         SequenceInputStream seqStream = new SequenceInputStream(stream1, stream2);

         byte[] buffer = new byte[10]; // larger buffer
         int bytesRead = seqStream.read(buffer, 2, 5); // read into index 2 onwards

         System.out.println("Bytes read: " + bytesRead);
         System.out.println("Buffer content: " + Arrays.toString(buffer));
         System.out.println("Read content: " + new String(buffer, 2, bytesRead));

         seqStream.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

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

Bytes read: 4
Buffer content: [0, 0, 74, 97, 118, 97, 0, 0, 0, 0]
Read content: Java

Explanation

• Reads up to 5 bytes from the stream into buffer starting at index 2.

• "Java123" has 7 bytes, so 5 are read into positions 2–6.

• Output shows how the buffer was filled and what was read.

Example - Read data in chunks using offset and length

The following example shows the usage of SequenceInputStream read(byte[] b,int off,int len) method.

SequenceInputStreamDemo.java

package com.tutorialspoint;

import java.io.ByteArrayInputStream;
import java.io.SequenceInputStream;
import java.io.IOException;

public class SequenceInputStreamDemo {
   public static void main(String[] args) {
      try {
         ByteArrayInputStream stream1 = new ByteArrayInputStream("ABC".getBytes());
         ByteArrayInputStream stream2 = new ByteArrayInputStream("DEF".getBytes());

         SequenceInputStream seqStream = new SequenceInputStream(stream1, stream2);

         byte[] buffer = new byte[4];
         int totalRead = 0;
         int n;

         // Read multiple times with len = 2
         while ((n = seqStream.read(buffer, 0, 2)) != -1) {
            System.out.print("Chunk read: ");
            System.out.println(new String(buffer, 0, n));
            totalRead += n;
         }

         System.out.println("Total bytes read: " + totalRead);
         seqStream.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

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

Chunk read: AB
Chunk read: C
Chunk read: DE
Chunk read: F
Total bytes read: 6

Explanation

• Reads the stream "ABCDEF" in chunks of 2 bytes.

• Uses a buffer of size 4 but reads into the first 2 positions each time.

• Tracks and prints each chunk read.