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

---

---

Description

The Java PipedInputStream read(byte[] b int off, int len) method reads up to len bytes of data from this piped input stream into an array of bytes. Less than len bytes will be read if the end of the data stream is reached or if len exceeds the pipe's buffer size. If len is zero, then no bytes are read and 0 is returned; otherwise, the method blocks until at least 1 byte of input is available, end of the stream has been detected, or an exception is thrown.

Declaration

Following is the declaration for java.io.PipedInputStream.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 the destination array b.

• len − The maximum number of bytes read.

Return Value

This method returns the total number of bytes read into the buffer, or -1 if there is no more data because the end of the stream has been reached.

Exception

• NullPointerException − If b is null.

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

• IOException − If the pipe is broken, unconnected, closed, or if an I/O error occurs.

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

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

PipedInputStreamDemo.java

package com.tutorialspoint;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class PipedInputStreamDemo {
   public static void main(String[] args) {
   
      // create a new Piped input and Output Stream
      PipedOutputStream out = new PipedOutputStream();
      PipedInputStream in = new PipedInputStream();

      try {
         // connect input and output
         in.connect(out);

         // write something 
         out.write(70);
         out.write(71);

         // read what we wrote into an array of bytes
         byte[] b = new byte[2];
         in.read(b, 0, 2);

         // print the array as a string
         String s = new String(b);
         System.out.println("" + s);
      } catch (IOException ex) {
         ex.printStackTrace();
      }
   }
}

Output

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

FG 

Example - Read a portion of data into a byte array with offset and length

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

PipedInputStreamDemo.java

package com.tutorialspoint;

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;

public class PipedInputStreamDemo {
   public static void main(String[] args) {
      try {
         PipedInputStream pis = new PipedInputStream();
         PipedOutputStream pos = new PipedOutputStream();
         pis.connect(pos);

         String message = "JavaPipeExample";
         pos.write(message.getBytes());

         byte[] buffer = new byte[20]; // Bigger than necessary

         // Read only 8 bytes, starting from buffer[5]
         int bytesRead = pis.read(buffer, 5, 8);

         System.out.println("Bytes read: " + bytesRead);
         System.out.println("Message read (with offset): " + new String(buffer, 5, bytesRead));

         pis.close();
         pos.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Output

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

Bytes read: 8
Message read (with offset): JavaPipe

Explanation

• read(byte[] b, int off, int len) reads up to len bytes of data into b, starting at index off.

• Here, data starts from buffer[5] and reads 8 bytes into it.

• This is useful when you're filling a buffer in segments.

Example - Read data from a producer thread into a buffer

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

PipedInputStreamDemo.java

package com.tutorialspoint;

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.io.IOException;

public class PipedInputStreamDemo {
   public static void main(String[] args) throws IOException {
      PipedInputStream pis = new PipedInputStream();
      PipedOutputStream pos = new PipedOutputStream(pis);

      Thread producer = new Thread(() -> {
         try {
            pos.write("Hello from thread!".getBytes());
            pos.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      });

      Thread consumer = new Thread(() -> {
         try {
            byte[] buffer = new byte[100];
            int bytesRead = pis.read(buffer, 0, buffer.length);
            System.out.println("Consumer received: " + new String(buffer, 0, bytesRead));
            pis.close();
         } catch (IOException e) {
            e.printStackTrace();
         }
      });

      producer.start();
      consumer.start();
   }
}

Output

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

Consumer received: Hello from thread!

Explanation

• This is a producer-consumer thread scenario.

• The consumer uses read(byte[] b, int off, int len) to read up to buffer.length bytes.

• This method is more efficient than read() because it reads in chunks instead of one byte at a time.