Java.io.PipedReader Class in Java

This class is basically a piped character-input streams.In I/O Piped, simply means a link between two threads running in JVM at the same time. So, Pipes are used both as source or destination.
A pipe is said to be broken if a thread that was providing data bytes to the connected piped output stream is no longer alive.

Declaration:

public class PipedReader
  extends Reader

Constructor :

• PipedReader() : creates a PipedReader(), that it is not connected.
• PipedReader(int pSize) : creates a PipedReader, that it is not connected with specified pipe size.
• PipedReader(PipedWriterStream src) : creates a PipedReader, that it is connected to PipedWriterStream – ‘src’.
• PipedReader(PipedWriterStream src, int pSize) : creates a Piped Reader that is connected to Piped Writer with the specified pipe size.

Methods:

• read() : java.io.PipedReader.read() reads the next character from PipedReader. This method blocks until characters are available. Returns -1 if end of the stream is detected, or an exception is thrown and the method blocks
  Syntax() :

  public int read()
  Parameters: 
  -----------
  Return :
  reads the next character from PipedReader.
  else, return-1 if end of the stream is detected.
  Exception : 
  -> IOException : if in case an IO error occurs.
  

  Implementation:

  // Java program illustrating the working of read() method
  
  import java.io.*;
  public class NewClass
  {
      public static void main(String[] args) throws IOException
      {
          PipedReader geek_reader = new PipedReader();
          PipedWriter geek_writer = new PipedWriter();
  
              geek_reader.connect(geek_writer);
  
              // Use of read() method
              geek_writer.write(71);
              System.out.println("using read() : " + (char)geek_reader.read());
              geek_writer.write(69);
              System.out.println("using read() : " + (char)geek_reader.read());
              geek_writer.write(75);
              System.out.println("using read() : " + (char)geek_reader.read());
      }
  }

  Output :

  using read() : G
  using read() : E
  using read() : K

• read(char[] carray, int offset, int maxlen) : java.io.PipedReader.read(char[] carray, int offset, int maxlen) reads upto maxlen character from PipedReader Stream to the character array. The method blocks if end of Stream is reached or exception is thrown.
  Syntax :

  public int read(char[] carray, int offset, int maxlen)
  Parameters : 
  carray : buffer into which the data is to be read
  offset : starting in the destination array - 'carray'.
  maxlen : maximum length of array to be read
  Return :                                               
  next 'maxlen' bytes of the data as an integer value 
  return -1 is end of stream is reached
  Exception :
  -> IOException : if in case IO error occurs.
  

• close() : java.io.PipedPipedReader.close() closes the PipedReader Stream and releases the allocated resources.
  Syntax :

  public void close()
  Parameters : 
  --------------
  Return :                                               
  void
  Exception :
  -> IOException : if in case IO error occurs.

• connect(PipedWriter source) : java.io.PipedReader.connect(PipedWriter source) connects the PipedReader to the ‘source’ Piped Writer and in case ‘source’ is pipes with some other stream, IO exception is thrown
  Syntax :

  public void connect(PipedWriter source)
  Parameters : 
  source : the PipedWriter to be connected to
  Return :                                               
  void
  Exception :
  -> IOException : if in case IO error occurs.

• ready() : java.io.PipedPipedReader.ready() tells whether the stream is ready to be read or not
  Syntax :

  public boolean ready()
  Parameters : 
  --------------
  Return :                                               
  true : if the stream is ready to be read else, false
  Exception :
  -> IOException : if in case IO error occurs.

  Java program illustrating the working of PipedReader class methods :

  // Java program illustrating the working of PipedReader
  // connect(), read(char[] carray, int offset, int maxlen),
  // close(), ready()
  
  import java.io.*;
  public class NewClass
  {
      public static void main(String[] args) throws IOException
      {
          PipedReader geek_reader = new PipedReader();
          PipedWriter geek_writer = new PipedWriter();
  
          // Use of connect() : connecting geek_reader with geek_writer
          geek_reader.connect(geek_writer);
  
          geek_writer.write(71);
          geek_writer.write(69);
          geek_writer.write(69);
          geek_writer.write(75);
          geek_writer.write(83);
  
          // Use of ready() method
          System.out.print("Stream is ready to be read : "+geek_reader.ready());
  
          // Use of read(char[] carray, int offset, int maxlen)
          System.out.print("\nUse of read(carray, offset, maxlen) : ");
          char[] carray = new char[5];
          geek_reader.read(carray, 0, 5);
  
          for (int i = 0; i < 5; i++)
          {
              System.out.print(carray[i]);
          }
  
          // USe of close() method :
          System.out.println("\nClosing the stream");
          geek_reader.close();
      }
  }

  Output :

  Stream is ready to be read : true
  Use of read(carray, offset, maxlen) : GEEKS
  Closing the stream

Next Article: Java.io.PipedWriter Class in Java