De PipedWriter-klass i Java tillåter två trådar att kommunicera med varandra genom att skicka data genom ett rör. Denna klass är användbar när vi vill att en del av programmet ska skicka data till en annan del utan att lagra den i minnet.

matriser i c-programmering

Funktioner i PipedWriter-klassen:

• Det gör det möjligt att skriva data i ett rör.
• Den använder en buffert för att tillfälligt lagra data innan den skickas till PipedReader.
• Det fungerar med PipedReader för att säkerställa säker dataöverföring mellan trådar.
• Om röret går sönder ger det ett fel.

Deklaration av PipedWriter i Java

Deklarationen för klassen PipedWriter är:

public class PipedWriter utökar Writer

Alla implementerade gränssnitt:

• Stängbar: Detta gränssnitt används av klasser som hanterar resurser.
• Detta gränssnitt används för att spola data till dess destination.
• Kan läggas till: Detta gränssnitt används för att lägga till data till en befintlig ström.
• Autostängbar: Detta gränssnitt tillåter automatisk stängning av resurser.

Konstruktörer i PipedWriter-klassen

Denna klass består av två konstruktorer med hjälp av vilka vi kan skapa objekt av denna klass på olika sätt. Följande är de konstruktörer som finns tillgängliga i den här klassen:

1. PipedWriter(): Denna konstruktor används för att skapa en PipedWriter som inte är ansluten till någonting ännu.

Syntax:

PipedWriter()

Exempel:

// 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): Denna konstruktor som vi använde för att skapa en PipedWriter och ansluter den till en PipedReader.

Syntax:

PipedWriter(PipedReader snk)

Exempel:

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

Bilden nedan visar metoderna i klassen PipedWriter.

Nu ska vi diskutera varje metod en efter en i detalj:

1. skriv(int char): Denna metod används för att skriva ett enstaka tecken till ett rör.

Syntax:

public void write(int char)

• Parameter: Denna metod tar en parameter som representerar det tecken som ska skrivas.
• Undantag: Denna metod returnerar IOException om det finns ett problem med I/O-operationen.

2. skriv(char[] carray int offset int maxlen): Denna metod används för att skriva tecken från en array till röret.

Syntax:

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

java innehåller delsträng

• Parameter: Denna metod inkluderar tre parametrar som listas nedan:
  • bära:
  • offset: Det är platsen i arrayen där man ska börja skriva form
  • maxlen: Det är det maximala antalet tecken att skriva.
• Undantag: Denna metod returnerar IOException om det finns ett problem med I/O-operationen.

3. anslut (PipedReader destination): Denna metod används för att ansluta PipedWriter till en PipedReader.

Syntax:

public void connect (PipedReader destination)

• Parameter: Denna metod tar en parameterdestination, det är PipedReader som PipedWriter kommer att ansluta till för dataöverföring.
• Undantag: Denna metod kastar IOException om ett fel uppstår under anslutning.

4. spola(): Denna metod används för att spola data i röret.

Syntax:

public void flush()

• Parameter: Denna metod tar inte någon parameter.
• Undantag: Denna metod kastar IOException om ett fel uppstår när data töms.

5. stäng():

Synatx:

public void close()

• Parameter: Denna metod tar inte någon parameter.
• Undantag: Denna metod kastar IOException om det finns ett problem med att stänga skrivaren.

Nu ska vi diskutera hur vi kan använda PipedWriter-klassen för att skriva data och läsa den genom en ansluten PipedReader

Exempel:

// 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-program som illustrerar hur PipedWriter klassmetoder fungerar

Nu kommer vi att skriva några karaktärer att spola utgången och stänga skribenten.

shloka mehta

Exempel:

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