Esta clase es básicamente un flujo de entrada de caracteres canalizado. En I/O Piped, simplemente significa un enlace entre dos subprocesos que se ejecutan en JVM al mismo tiempo. Por lo tanto, las tuberías se utilizan como origen o como destino.
Se dice que una canalización está rota si un subproceso que proporcionaba bytes de datos al flujo de salida canalizado conectado ya no está activo.
Declaración:
public class PipedReader extends Reader
Constructor:
- PipedReader() : crea un PipedReader(), que no está conectado.
- PipedReader (int pSize): crea un PipedReader, que no está conectado con el tamaño de tubería especificado.
- PipedReader(PipedWriterStream src) : crea un PipedReader, que está conectado a PipedWriterStream – ‘src’.
- PipedReader(PipedWriterStream src, int pSize): crea un Piped Reader que está conectado a Piped Writer con el tamaño de tubería especificado.
Métodos:
- read() : java.io.PipedReader.read() lee el siguiente carácter de PipedReader. Este método bloquea hasta que los caracteres estén disponibles. Devuelve -1 si se detecta el final de la secuencia, o si se lanza una excepción y el método bloquea
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.
Implementación:
// 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());
}
}
Producción :
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) lee hasta el carácter maxlen de PipedReader Stream a la array de caracteres. El método se bloquea si se alcanza el final de Stream o se lanza una excepción.
Sintaxis: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() cierra PipedReader Stream y libera los recursos asignados.
Sintaxis:public void close() Parameters : -------------- Return : void Exception : -> IOException : if in case IO error occurs.
- connect (fuente de PipedWriter) : java.io.PipedReader.connect (fuente de PipedWriter) conecta el PipedReader al ‘fuente’ Piped Writer y en caso de que ‘fuente’ sea canalizaciones con alguna otra secuencia, se lanza una excepción de IO
Sintaxis: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() indica si la transmisión está lista para ser leída o no
Sintaxis :public boolean ready() Parameters : -------------- Return : true : if the stream is ready to be read else, false Exception : -> IOException : if in case IO error occurs.
Programa Java que ilustra el funcionamiento de los métodos de la clase PipedReader:
// 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();
}
}
Producción :
Stream is ready to be read : true Use of read(carray, offset, maxlen) : GEEKS Closing the stream
Artículo siguiente: Clase Java.io.PipedWriter en Java
Este artículo es aportado por Mohit Gupta 🙂 . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo usando contribuya.geeksforgeeks.org o envíe su artículo por correo a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.
Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo electrónico a contribuya@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA