Java.io.PipedReader Class in Java

Read

Practice

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

Java.io.StringWriter class in Java

Java.io.FileDescriptor in Java

Share your thoughts in the comments

Feb	MAR	Apr
	05
2023	2024	2025

Java.io.PipedReader Class in Java

Please Login to comment...

What kind of Experience do you want to share?