Classe Java Piped Writer
O Classe PipedWriter em Java permite que dois threads se comuniquem entre si, passando dados por um canal. Esta classe é útil quando queremos que uma parte do programa envie dados para outra parte sem armazená-los na memória.
Recursos da classe PipedWriter:
- Permite gravar dados em um pipe.
- Ele usa um buffer para armazenar dados temporariamente antes de enviá-los ao PipedReader.
- Funciona com PipedReader para garantir a transferência segura de dados entre threads.
- Se o tubo quebrar, ocorrerá um erro.
Declaração de PipedWriter em Java
A declaração da classe PipedWriter é:
classe pública PipedWriter estende o Writer
Todas as interfaces implementadas:
- Fechável: Essa interface é usada por classes que manipulam recursos.
- Lavável: Esta interface é usada para liberar dados para seu destino.
- Anexável: Esta interface é usada para anexar dados a um fluxo existente.
- Fechamento automático: Esta interface permite o fechamento automático de recursos.
Construtores na classe PipedWriter
Esta classe consiste em dois construtores com os quais podemos criar objetos desta classe de diferentes maneiras. A seguir estão os construtores disponíveis nesta classe:
1. PipedWriter(): Este construtor é usado para criar um PipedWriter que ainda não está conectado a nada.
Sintaxe:
PipedWriter()
Exemplo:
Java // Demonstrating the working // of PipedWriter() import java.io.* ; class Geeks { public static void main ( String [] args ) { // Create PipedWriter and PipedReader PipedWriter w = new PipedWriter (); PipedReader r = new PipedReader (); try { // Connect the PipedWriter to the PipedReader w . connect ( r ); // Create a thread to write data into the pipe Thread writerThread = new Thread ( new Runnable () { public void run () { try { w . write ( 'Hello from PipedWriter!' ); w . close (); } catch ( IOException e ) { e . printStackTrace (); } } }); // Create a thread to read data from the pipe Thread readerThread = new Thread ( new Runnable () { public void run () { try { int data ; while (( data = r . read ()) != - 1 ) { System . out . print (( char ) data ); } r . close (); } catch ( IOException e ) { e . printStackTrace (); } } }); // Start both threads writerThread . start (); readerThread . start (); // Wait for both threads to finish writerThread . join (); readerThread . join (); } catch ( IOException | InterruptedException e ) { e . printStackTrace (); } } }
Saída
Hello from PipedWriter!
2. PipedWriter (PipedReader inStream): Este construtor usamos para criar um PipedWriter e conectá-lo a um PipedReader.
Sintaxe:
PipedWriter(PipedReader snk)
Exemplo:
Java // Demonstrating the working // PipedWriter(PipedReader snk) import java.io.* ; public class Geeks { public static void main ( String [] args ) { try { // Create a PipedReader and a PipedWriter PipedReader r = new PipedReader (); PipedWriter w = new PipedWriter ( r ); // Create a thread to write data to the PipedWriter Thread writerThread = new Thread (() -> { try { w . write ( 'Hello PipedWriter' ); w . close (); } catch ( IOException e ) { e . printStackTrace (); } }); // Create a thread to read data from the PipedReader Thread readerThread = new Thread (() -> { try { int data ; while (( data = r . read ()) != - 1 ) { System . out . print (( char ) data ); } } catch ( IOException e ) { e . printStackTrace (); } }); // Start both threads writerThread . start (); readerThread . start (); // Wait for both threads to finish writerThread . join (); readerThread . join (); } catch ( IOException | InterruptedException e ) { e . printStackTrace (); } } }
Saída
Hello PipedWriter
Métodos Java PipedWriter
A imagem abaixo demonstra os métodos da classe PipedWriter.
Agora vamos discutir cada método, um por um, em detalhes:
1. escrever(int char): Este método é usado para gravar um único caractere em um canal.
Sintaxe:
escrita nula pública (int char)
- Parâmetro: Este método usa um parâmetro que é ischar representando o caractere a ser escrito.
- Exceção: Este método retorna IOException se houver um problema com a operação de E/S.
2. escrever (char[] carray int offset int maxlen): Este método é usado para escrever caracteres de um array no pipe.
Sintaxe:
escrita void pública (char[] carray int offset int maxlen)
- Parâmetro: Este método inclui três parâmetros listados abaixo:
- carro: É a matriz de caracteres que contém dados
- desvio: É a posição no array onde começar a escrever o formulário
- maxlen: É o número máximo de caracteres a serem escritos.
- Exceção: Este método retorna IOException se houver um problema com a operação de E/S.
3. conectar (destino do PipeReader): Este método é usado para conectar o PipedWriter a um PipedReader.
Sintaxe:
conexão pública void (destino PipedReader)
- Parâmetro: Este método leva um destino de parâmetro: é o PipedReader ao qual o PipedWriter se conectará para transferência de dados.
- Exceção: Este método lança IOException se ocorrer um erro durante a conexão.
4. descarga(): Este método é usado para liberar dados no pipe.
Sintaxe:
liberação de vazio público()
- Parâmetro: Este método não aceita nenhum parâmetro.
- Exceção: Este método lança IOException se ocorrer um erro ao liberar os dados.
5. fechar(): Este método é usado para fechar o PipedWriter.
Sintaxe:
fechamento de vazio público()
- Parâmetro: Este método não aceita nenhum parâmetro.
- Exceção: Este método lança IOException se houver um problema ao fechar o gravador.
Agora discutiremos como podemos usar a classe PipedWriter para escrever dados e lê-los através de um PipedReader conectado
Exemplo:
Java // Demonstrating how to use PipedReader // and PipedWriter to transferr an array // of characters between two threads import java.io.* ; public class Geeks { public static void main ( String [] args ) throws IOException { PipedReader r = new PipedReader (); PipedWriter w = new PipedWriter (); r . connect ( w ); // Must connect before use // Writing a char array char [] c = { 'J' 'A' 'V' 'A' }; w . write ( c 0 4 ); // Reading blocks if no data is written yet System . out . print ( 'Output from the pipe:' ); for ( int i = 0 ; i < 4 ; i ++ ) { System . out . print ( ' ' + ( char ) r . read ()); } w . close (); r . close (); } }
Saída
Output from the pipe: J A V A
Programa Java que ilustra o funcionamento dos métodos da classe PipedWriter
Agora vamos escrever alguns caracteres para liberar a saída e fechar o gravador.
Exemplo:
Java // Java program illustrating the working of PipedWriter // write() connect // close() flush() import java.io.* ; public class Geeks { public static void main ( String [] args ) throws IOException { PipedReader r = new PipedReader (); PipedWriter w = new PipedWriter (); try { // Use of connect(): Connecting the writer to the reader r . connect ( w ); // Use of write(int byte): Writing characters to the pipe w . write ( 71 ); w . write ( 69 ); w . write ( 69 ); w . write ( 75 ); w . write ( 83 ); // Use of flush() method: Flushing the output to // make sure all data is written w . flush (); System . out . println ( 'Output after flush():' ); // Reading from the pipe for ( int i = 0 ; i < 5 ; i ++ ) { System . out . print ( ' ' + ( char ) r . read ()); } // Use of close() method: Closing the writer System . out . println ( 'nClosing the Writer stream' ); w . close (); } catch ( IOException e ) { e . printStackTrace (); } } }
Saída
Output after flush(): G E E K S Closing the Writer streamCriar questionário
