it-swarm.it

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

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

33
Ajay Yadav

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

Potete immaginare la differenza di efficienza con la lettura di un carattere (o byte) di fronte a 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 otterranno una maggiore efficienza.

InputStreamReader converte i flussi di byte in stream 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 sia d'aiuto.

37
amod

La classe InputStreamReader adatta type InputStream (byte non interpretati) alla classe Reader (byte interpretati come caratteri in alcuni set di caratteri), ma non applica alcun buffer aggiuntivo. La classe BufferedReader accetta una classe Reader (presumibilmente unbuffered) e applica il buffering ad essa.

16

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

BufferedReader utilizza una tecnica chiamata buffering che ci consente di ridurre la frequenza con cui leggiamo dal disco/STDIN copiando i blocchi nella memoria principale. 

Tenere conto:

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!)

Dalla documentazione :

Senza buffering, ciascuna invocazione di read() potrebbe causare la lettura di byte da [disk/STDIN], convertiti in caratteri e quindi restituiti, che può essere molto inefficiente.

Le due classi implementano la stessa interfaccia di Reader. Quindi, mentre si può usare solo InputStreamReader senza BufferedReader, potrebbe risultare scarso rendimento. Stiamo semplicemente usando decorator pattern qui in modo che ci ritroviamo con un InputStreamReader che ora ha una capacità di buffering.

15
James Lawson

BufferedReader legge un paio di caratteri dallo stream 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 (), ho inserito l'input "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 l'input "ciao" e il rimanente "Ello" rimane ancora 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 che leggerà più di quello) dal flusso di input e li memorizzerà 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 solo un 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 vogliono leggere caratteri da System.in, allora in quel caso dovrebbe essere usato InputStreamReader perché legge solo un carattere e il rimanente può essere usato da altri oggetti o thread.

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

BufferedReader legge un paio di caratteri dal flusso di input e li memorizza in un buffer.

InputStreamReader legge solo un carattere dal flusso di input e i restanti caratteri rimangono ancora nei flussi, quindi in questo caso non vi è alcun buffer.

1
Ehsan Mashhadi

Come ho capito, invece di InputStreamReader BufferedReader richiede meno tempo per convertire i dati da byte a character.so preferiamo BufferedReader per prestazioni migliori

0
user8732605