Java PipedWriter-klasse
De PipedWriter-klasse in Java zorgt ervoor dat twee threads met elkaar kunnen communiceren door gegevens door een pijp te sturen. Deze klasse is handig als we willen dat een deel van het programma gegevens naar een ander deel verzendt zonder deze in het geheugen op te slaan.
Kenmerken van de PipedWriter-klasse:
- Hiermee kunt u gegevens in een pijp schrijven.
- Het gebruikt een buffer om gegevens tijdelijk op te slaan voordat deze naar de PipedReader worden verzonden.
- Het werkt met PipedReader om een veilige gegevensoverdracht tussen threads te garanderen.
- Als de leiding breekt, geeft dit een foutmelding.
Verklaring van PipedWriter in Java
De declaratie van de PipedWriter-klasse is:
openbare klasse PipedWriter breidt Writer uit
Alle geïmplementeerde interfaces:
- Afsluitbaar: Deze interface wordt gebruikt door klassen die bronnen verwerken.
- Doorspoelbaar: Deze interface wordt gebruikt om gegevens naar de bestemming te spoelen.
- Toevoegbaar: Deze interface wordt gebruikt om gegevens aan een bestaande stream toe te voegen.
- Automatisch Sluitbaar: Deze interface maakt het automatisch sluiten van bronnen mogelijk.
Constructeurs in de PipedWriter-klasse
Deze klasse bestaat uit twee constructors met behulp waarvan we op verschillende manieren objecten van deze klasse kunnen maken. De volgende constructors zijn beschikbaar in deze klasse:
1. PipedWriter(): Deze constructor wordt gebruikt om een PipedWriter te maken die nog nergens mee verbonden is.
Syntaxis:
PipedWriter()
Voorbeeld:
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 (); } } }
Uitvoer
Hello from PipedWriter!
2. PipedWriter(PipedReader inStream): Deze constructor hebben we gebruikt om een PipedWriter te maken en deze te verbinden met een PipedReader.
Syntaxis:
PipedWriter(PipedReader snk)
Voorbeeld:
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 (); } } }
Uitvoer
Hello PipedWriter
Java PipedWriter-methoden
De onderstaande afbeelding demonstreert de methoden van de PipedWriter-klasse.
Nu gaan we elke methode één voor één in detail bespreken:
1. schrijf(int char): Deze methode wordt gebruikt om één enkel teken naar een pipe te schrijven.
Syntaxis:
openbare leegte schrijven (int char)
- Parameter: Bij deze methode wordt één parameter gebruikt die het te schrijven teken vertegenwoordigt.
- Uitzondering: Deze methode retourneert IOException als er een probleem is met de I/O-bewerking.
2. schrijven(char[] carray int offset int maxlen): Deze methode wordt gebruikt om tekens uit een array naar de pipe te schrijven.
Syntaxis:
public void write(char[] carray int offset int maxlen)
- Parameter: Deze methode omvat drie parameters die hieronder worden vermeld:
- wagen: Het is de karakterarray die gegevens bevat
- compensatie: Het is de positie in de array waar het formulier moet worden geschreven
- maxlen: Het is het maximale aantal tekens dat u kunt schrijven.
- Uitzondering: Deze methode retourneert IOException als er een probleem is met de I/O-bewerking.
3. connect(PipedReader-bestemming): Deze methode wordt gebruikt om de PipedWriter met een PipedReader te verbinden.
Syntaxis:
public void connect (PipedReader-bestemming)
- Parameter: Deze methode heeft één parameterbestemming nodig: de PipedReader waarmee de PipedWriter verbinding zal maken voor gegevensoverdracht.
- Uitzondering: Deze methode genereert IOException als er een fout optreedt tijdens het verbinden.
4. doorspoelen(): Deze methode wordt gebruikt om gegevens in de pijpleiding te spoelen.
Syntaxis:
openbare leegte flush()
- Parameter: Deze methode gebruikt geen enkele parameter.
- Uitzondering: Deze methode genereert IOException als er een fout optreedt tijdens het leegmaken van de gegevens.
5. sluiten(): Deze methode wordt gebruikt om PipedWriter te sluiten.
Synatx:
openbare leegte close()
- Parameter: Deze methode gebruikt geen enkele parameter.
- Uitzondering: Deze methode genereert IOException als er een probleem is met het sluiten van de schrijver.
Nu zullen we bespreken hoe we de klasse PipedWriter kunnen gebruiken om gegevens te schrijven en deze te lezen via een aangesloten PipedReader
Voorbeeld:
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 (); } }
Uitvoer
Output from the pipe: J A V A
Java-programma dat de werking van PipedWriter-klassemethoden illustreert
Nu zullen we enkele karakters schrijven, de uitvoer doorspoelen en de schrijver sluiten.
Voorbeeld:
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 (); } } }
Uitvoer
Output after flush(): G E E K S Closing the Writer streamQuiz maken
