Open In App
Related Articles

Java.io.PipedReader Class in Java

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report
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

    Last Updated : 23 Jan, 2017
    Like Article
    Save Article
    Previous
    Next
    Share your thoughts in the comments
Similar Reads