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.

scanner java próximo

Sintaxe:

PipedWriter()

mineração de dados

Exemplo:

// 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();  }  } } 

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:

// 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();  }  } } 

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:

Kat timp

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:

string java indexof

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.

execvp

Agora discutiremos como podemos usar a classe PipedWriter para escrever dados e lê-los através de um PipedReader conectado

Exemplo:

// 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();   }  } 

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 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();  }  } } 

Output after flush(): G E E K S Closing the Writer stream