Qual è la differenza tra le classi Java di BufferedReader e InputStreamReader?

Question

Qual è la differenza tra le classi Java BufferedReader e InputStreamReader?

Answer 1

BufferedReader è un wrapper per "InputStreamReader/FileReader", che bufferizza le informazioni ogni volta che viene chiamato un I/O nativo.

Si può immaginare la differenza di efficienza con la lettura di un carattere (o byte) rispetto alla lettura di un grande no. di caratteri in un colpo solo (o byte). Con BufferedReader, se si desidera leggere un singolo carattere, esso memorizzerà il contenuto per riempire il suo buffer (se è vuoto) e per ulteriori richieste, i caratteri verranno letti direttamente dal buffer, e quindi otterrà una maggiore efficienza.

InputStreamReader converte i flussi di byte in flussi di caratteri. Legge byte e li decodifica in caratteri usando un set di caratteri specificato. Il set che utilizza può essere specificato per nome o può essere fornito in modo esplicito oppure può essere accettato il set di caratteri predefinito della piattaforma.

Spero che aiuti.

Answer 2

La classe InputStreamReader adatta digitare InputStream (byte non) alla classe Reader (bytes interpretati come caratteri in un insieme di caratteri), ma non si applica buffering aggiuntivo. La classe BufferedReader prende una classe Reader (presumibilmente unbuffered) e applica il buffering ad essa.

Answer 3

La lettura dalla memoria principale è più veloce della lettura da disco/STDIN.

BufferedReader utilizza una tecnica chiamata buffer che ci permette di ridurre la frequenza con leggiamo dal disco/STDIN copiando blocchi alla memoria principale.

consideri:

BufferedReader in = new InputStreamReader(System.in); 
in.read(); // 
in.read(); // 
// ... 
in.read(); // could be hitting the disk/STDIN a lot (slow!) 

vs:

BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); 
in.read(); // 
in.read(); // 
// ... 
in.read(); // hitting main memory a lot (fast!) 

Dal documentation:

Senza buffer, ogni chiamata di read() potrebbero causare byte da leggere dal [disc/STDIN], convertito in caratteri e quindi restituito, che può essere molto inefficiente.

Le due classi implementano la stessa interfaccia di Reader. Pertanto, mentre è possibile utilizzare solo InputStreamReader senza BufferedReader, il risultato potrebbe essere scarso rendimento. Stiamo usando il decorator pattern qui in modo che ci ritroviamo con uno InputStreamReader che ha ora una capacità di buffering.

Answer 4

Mi pare di capire che invece di InputStreamReader BufferedReader richiede meno tempo per convertire i dati dal byte da character.so preferiamo BufferedReader per migliorare le prestazioni

Answer 5

BufferedReader legge un paio di caratteri dal flusso specificato e lo memorizza in un buffer. Questo rende l'input più veloce.

InputStreamReader legge solo un carattere dal flusso specificato e i caratteri rimanenti rimangono nel flusso.

Esempio:

class NewClass{  
    public static void main(String args[]) throws IOException{ 

     BufferedReader isr = new BufferedReader(new InputStreamReader(System.in)); 

     Scanner sc = new Scanner(System.in); 

     System.out.println("B.R. - "+(char)isr.read()); 
     System.out.println("Scanner - " + sc.nextLine());  
    } 
} 

Quando viene eseguita l'istruzione isr.read(), sono entrato l'ingresso “ciao” e il carattere “h” di “ciao” è stampato sullo schermo. Se fosse InputStreamReader, i caratteri rimanenti "ello" sarebbero rimasti nel flusso System.in e sc.nextLine() li avrebbe stampati. Ma in questo caso non succede perché BufferedReader legge tutti i caratteri "ciao" dal flusso System.in e li memorizza nel proprio buffer personale e quindi il flusso System.in rimane vuoto quando sc.nextLine() è eseguito.

Per il codice:

class NewClass{  

    public static void main(String args[]) throws IOException{ 

     InputStreamReader isr = new InputStreamReader(System.in); 

     Scanner sc = new Scanner(System.in); 

     System.out.println("I.S.R. - "+(char)isr.read()); 
     System.out.println("Scanner - " + sc.nextLine()); 

    } 
} 

In questo caso InputStreamReader legge solo un carattere per “ciao” di ingresso e il restante “ello” rimangono nel flusso System.in e questi caratteri vengono stampati da sc. nextLine();

Conclusione:

BufferedReader legge un paio di caratteri (anche se vogliamo un solo carattere si leggerà di più) dal flusso di input e li memorizza in un buffer. Ecco perché è chiamato BufferedReader. Non ero in grado di capire quanti caratteri leggeva in una volta sola. Variava da 3 a 10 quando l'ho testato per questa risposta.

InputStreamReader legge un solo carattere dal flusso di input e i caratteri rimanenti rimangono nel flusso. Non c'è un buffer intermedio in questo caso.

Quando uno o più thread o oggetti desiderano leggere i caratteri da System.in, in questo caso deve essere utilizzato InputStreamReader perché legge solo un carattere e il rimanente può essere utilizzato da altri oggetti o thread.

BufferedReader è veloce perché mantiene un buffer e il recupero dei dati dal buffer è sempre rapido rispetto al recupero dei dati da disco/stdin.