Java.io.PipedReader Class in Java
Last Updated :
23 Jan, 2017
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:
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);
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 :
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);
geek_writer.write( 71 );
geek_writer.write( 69 );
geek_writer.write( 69 );
geek_writer.write( 75 );
geek_writer.write( 83 );
System.out.print( "Stream is ready to be read : " +geek_reader.ready());
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]);
}
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
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...