IL Classe PipedReader in Java fa parte del java.io pacchetto e viene utilizzato per leggere i dati dei caratteri da una pipe. Questa classe consente la comunicazione tra thread in cui un thread scrive i dati utilizzando un PipedWriter e un altro li legge utilizzando PipedReader.

Caratteristiche della classe PipedReader:

• Permette la lettura dei dati attraverso una pipe.
• Utilizza un buffer per archiviare i dati ricevuti da PipedWriter.
• Funziona con PipedWriter per garantire che i dati vengano trasferiti in modo sicuro tra i thread.
• Se il tubo si rompe genera un errore.

Cos'è una pipe in Java?

In Java viene utilizzata una pipe per collegare due thread. Un thread viene utilizzato per inviare dati attraverso la pipe e l'altro thread legge i dati. Se il thread che sta inviando i dati si interrompe o si blocca, la pipe viene considerata rotta.

Dichiarazione della classe PipedReader

La dichiarazione della classe PipedReader è:

la classe pubblica PipedReader estende Reader

Tutte le interfacce implementate:

• Chiudibile: Questa interfaccia viene utilizzata per chiudere il flusso e rilasciare le risorse quando non sono più necessarie.
• Chiusura automatica: Questa interfaccia consente la gestione automatica delle risorse nelle istruzioni try-with-resources.
• Leggibile: Questa interfaccia consente la lettura dei dati dal flusso.

Costruttori di PipedReader

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

1. PipedReader(): Questo costruttore crea un PipedReader che non è ancora connesso a nessun writer.

Sintassi:

PipedReader pubblico()

2. PipedReader(int pipeSize): Questo costruttore crea aPipedREader con una dimensione di pipe specificata.

Sintassi:

public PipedReader(int pSize)

3. PipedReader(PipedWriter origine): Questo costruttore crea un PipedReader connesso a PipedWriterStream src.

public PipedReader(PipedWriter origine)

4. PipedReader(PipedWriter src int pipeSize): Questo costruttore crea un PidReader connesso con una dimensione specificata e collegato al PipedWriter specificato.

Sintassi:

public PipedReader(PipedWriter src int pSize)

Metodi Java PipedReader

L'immagine seguente mostra i metodi della classe PipedReader.

Ora discuteremo di ciascun metodo uno per uno in dettaglio:

1. leggere(): Questo metodo viene utilizzato per ottenere il carattere successivo da PipedReader. Si blocca finché non ci sono dati da leggere o si verifica un errore.

Sintassi:

public int read() lancia IOException

• Parametro: Questo metodo non accetta alcun parametro.
• Tipo di reso: Questo metodo restituisce il carattere successivo come numero intero o restituisce -1 se viene raggiunta la fine del flusso.
  

Esempio:

   // Demonstrating the working    // of read() method   import     java.io.*  ;   public     class   GeeKs     {          public     static     void     main  (  String  []     args  )     throws     IOException     {          PipedReader     r     =     new     PipedReader  ();      PipedWriter     w     =     new     PipedWriter  ();      // Connect the reader and writer      r  .  connect  (  w  );      // Write data to the PipedWriter      w  .  write  (  71  );         System  .  out  .  println  (  'Read: '     +     (  char  )     r  .  read  ());         w  .  write  (  69  );         System  .  out  .  println  (  'Read: '     +     (  char  )     r  .  read  ());         w  .  write  (  75  );         System  .  out  .  println  (  'Read: '     +     (  char  )     r  .  read  ());         }   }   

Read: G Read: E Read: K  

2. leggi(char[] carray int offset int maxlen): Questo metodo viene utilizzato per leggere fino a maxlen caratteri da PipedReader Stream nell'array di caratteri. Il metodo si blocca se viene raggiunta la fine del flusso o se viene generata un'eccezione.

Sintassi:

public int read(char[] carray int offset int maxlen) lancia IOException

• Parametro: Questo metodo include tre parametri elencati di seguito:
  • carrozza: È il buffer in cui verranno letti i dati.
  • offset: È la posizione iniziale nell'array
  • maxlen: Il numero massimo di caratteri da leggere nell'array.
• Tipo di reso: Questo metodo restituisce maxlen byte di dati come valore intero oppure restituisce -1 se viene raggiunta la fine del flusso
  

Esempio:

   // Demonstrating the working    // of read(char[] carray int offset int maxlen)    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  );      // Write data to PipedWriter      w  .  write  (  71  );     // G      w  .  write  (  69  );     // E      w  .  write  (  75  );     // K      w  .  write  (  83  );     // S      // Read data into an array      char  []     b     =     new     char  [  5  ]  ;      r  .  read  (  b       0       5  );          System  .  out  .  print  (  'Read characters: '  );      for     (  char     c     :     b  )     {      System  .  out  .  print  (  c  );         }      }   }   

Read characters: GEKS 

3. chiudi(): Questo metodo viene utilizzato per chiudere PipedReader.

Sintassi:

public void close() genera IOException

• Parametro: Questo metodo non accetta alcun parametro
• Tipo di reso: Questo metodo non restituisce nulla
  

Esempio:

   // Demonstrating the working   // of close() method   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  );      w  .  write  (  71  );         // Close the reader      r  .  close  ();      System  .  out  .  println  (  'Stream closed.'  );      }   }   

Stream closed.  

4. pronto(): Questo metodo viene utilizzato per verificare se il flusso è pronto per essere letto.

Sintassi:

public boolean ready() lancia IOException

• Parametro: Questo metodo non accetta alcun parametro
• Tipo di reso: Questo metodo restituisce true se il flusso è pronto per essere letto altrimenti restituisce false.
  

Esempio:

   // Demonstrating the working   // of ready() method   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  );      w  .  write  (  71  );         // Check if the stream is ready to be read      System  .  out  .  println  (  'Stream is ready to be read: '     +     r  .  ready  ());      }   }   

Stream is ready to be read: true  

5. chiudi(): Questo metodo viene utilizzato per chiudere i flussi PipedReader.

Sintassi:

pubblico vuoto chiuso()

• Parametro: Questo metodo non accetta alcun parametro.
• Tipo di reso: Questo metodo non restituisce nulla.

Esempio:

   // Demonstrating the working   // of close() method   import     java.io.*  ;   public     class   Geeks  {          public     static     void     main  (  String  []     args  )     {          try     {      // Create a PipedReader and PipedWriter      PipedReader     r     =     new     PipedReader  ();      PipedWriter     w     =     new     PipedWriter  ();      // Connect the PipedReader to the PipedWriter      r  .  connect  (  w  );      // Write a character to the PipedWriter      w  .  write  (  'A'  );          // Read and print the character from the PipedReader      System  .  out  .  println  (  'Read: '     +     (  char  )     r  .  read  ());     // Output: A      // Close the PipedReader stream      r  .  close  ();      System  .  out  .  println  (  'Stream closed.'  );      }     catch     (  IOException     e  )     {      e  .  printStackTrace  ();      }      }   }   

Read: A Stream closed.