Classe Java PipedWriter
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()
Esempio:
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 (); } } }
Produzione
Hello from PipedWriter!
2. PipedWriter (PipedReader inStream): Questo costruttore veniva utilizzato per creare un PipedWriter e collegarlo a un PipedReader.
Sintassi:
PipedWriter(PipedReader snk)
Esempio:
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 (); } } }
Produzione
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:
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.
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:
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 (); } }
Produzione
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 // 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 (); } } }
Produzione
Output after flush(): G E E K S Closing the Writer streamCrea quiz
