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:

internet gebruiken

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:

// 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): Deze constructor hebben we gebruikt om een ​​PipedWriter te maken en deze te verbinden met een PipedReader.

Syntaxis:

PipedWriter(PipedReader snk)

Voorbeeld:

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

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.

inorder boomtraversatie

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:

minimax-algoritme

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:

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

Java-programma dat de werking van PipedWriter-klassemethoden illustreert

Nu zullen we enkele karakters schrijven, de uitvoer doorspoelen en de schrijver sluiten.

Voorbeeld:

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