IL Classe PipedWriter in Java consente a due thread di comunicare tra loro facendo passare i dati attraverso una pipe. Questa classe è utile quando vogliamo che una parte del programma invii dati ad un'altra parte senza memorizzarli in memoria.

Caratteristiche della classe PipedWriter:

• Permette di scrivere dati in una pipe.
• Utilizza un buffer per archiviare temporaneamente i dati prima di inviarli a PipedReader.
• Funziona con PipedReader per garantire un trasferimento sicuro dei dati tra i thread.
• Se il tubo si rompe genera un errore.

Dichiarazione di PipedWriter in Java

La dichiarazione della classe PipedWriter è:

la classe pubblica PipedWriter estende Writer

Tutte le interfacce implementate:

• Chiudibile: Questa interfaccia viene utilizzata dalle classi che gestiscono le risorse.
• Lavabile: Questa interfaccia viene utilizzata per trasferire i dati alla destinazione.
• Aggiungibile: Questa interfaccia viene utilizzata per aggiungere dati a un flusso esistente.
• Chiusura automatica: Questa interfaccia consente la chiusura automatica delle risorse.

Costruttori nella classe PipedWriter

Questa classe è composta da due costruttori con l'aiuto dei quali possiamo creare oggetti di questa classe in diversi modi. Di seguito sono riportati i costruttori disponibili in questa classe:

1. PipedWriter(): Questo costruttore viene utilizzato per creare un PipedWriter che non è ancora connesso a nulla.

Sintassi:

PipedWriter()

attrice cinematografica rekha

Esempio:

// 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): Questo costruttore veniva utilizzato per creare un PipedWriter e collegarlo a un PipedReader.

metodi stringa java

Sintassi:

PipedWriter(PipedReader snk)

Esempio:

// 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

Metodi Java PipedWriter

L'immagine seguente mostra i metodi della classe PipedWriter.

Ora discuteremo di ciascun metodo uno per uno in dettaglio:

1. scrivi(int char): Questo metodo viene utilizzato per scrivere un singolo carattere su una pipe.

Sintassi:

public void write(int char)

• Parametro: Questo metodo accetta un parametro che è char che rappresenta il carattere da scrivere.
• Eccezione: Questo metodo restituisce IOException se si verifica un problema con l'operazione di I/O.

2. write(char[] carray int offset int maxlen): Questo metodo viene utilizzato per scrivere caratteri da un array alla pipe.

Sintassi:

public void write(char[] carray int offset int maxlen)

• Parametro: Questo metodo include tre parametri elencati di seguito:
  • carrozza: È l'array di caratteri che contiene i dati
  • offset: È la posizione nell'array da cui iniziare a scrivere il modulo
  • maxlen: È il numero massimo di caratteri da scrivere.
• Eccezione: Questo metodo restituisce IOException se si verifica un problema con l'operazione di I/O.

3. connettersi (destinazione PipedReader): Questo metodo viene utilizzato per connettere PipedWriter a PipedReader.

Sintassi:

al metodo string in Java

connessione pubblica vuota (destinazione PipedReader)

• Parametro: Questo metodo accetta una destinazione del parametro: è il PipedReader a cui PipedWriter si connetterà per il trasferimento dei dati.
• Eccezione: Questo metodo genera IOException se si verifica un errore durante la connessione.

4. arrossire(): Questo metodo viene utilizzato per svuotare i dati nella pipe.

Sintassi:

svuotamento pubblico()

• Parametro: Questo metodo non accetta alcun parametro.
• Eccezione: Questo metodo genera IOException se si verifica un errore durante lo scaricamento dei dati.

strutture dati Java

5. chiudi(): Questo metodo viene utilizzato per chiudere PipedWriter.

Sinatx:

pubblico vuoto chiuso()

• Parametro: Questo metodo non accetta alcun parametro.
• Eccezione: Questo metodo genera IOException se si verifica un problema con la chiusura del writer.

Ora discuteremo di come possiamo utilizzare la classe PipedWriter per scrivere dati e leggerli tramite un PipedReader connesso

Esempio:

// 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

Programma Java che illustra il funzionamento dei metodi della classe PipedWriter

Ora scriveremo alcuni caratteri, scarichiamo l'output e chiudiamo lo scrittore.

Esempio:

// 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