Scanner vs. BufferedReader

Per quanto ne so, i due metodi più comuni per leggere i dati basati sui caratteri da un file in Java sono gli Scanner o BufferedReader . So anche che BufferedReader legge i file in modo efficiente usando un buffer per evitare le operazioni del disco fisico. Le mie domande sono:

  • Scanner funziona come BufferedReader ?
  • Perché scegliere Scanner su BufferedReader o viceversa?

Scanner viene utilizzato per analizzare i token dal contenuto dello stream mentre BufferedReader legge il stream e non esegue alcuna analisi speciale.

In effetti, è ansible passare un BufferedReader a uno scanner come fonte di caratteri da analizzare.

Nell’ultima versione / build di JDK6 (b27), lo Scanner ha un buffer più piccolo ( 1024 caratteri ) rispetto a BufferedReader ( 8192 caratteri ), ma è più che sufficiente.

Per quanto riguarda la scelta, utilizzare lo Scanner se si desidera analizzare il file, utilizzare BufferedReader se si desidera leggere il file riga per riga. Vedi anche il testo introduttivo delle loro documentazioni API aforelinked.

  • Parsing = interpretare l’input dato come token (parti). È in grado di restituire parti specifiche direttamente come int, stringhe, decimali, ecc. Vedere anche tutti i metodi nextXxx() nella class Scanner .
  • Lettura = streaming stupido. Continua a restituirti tutti i personaggi, che a tua volta devono ispezionare manualmente se desideri abbinare o comporre qualcosa di utile. Ma se non hai bisogno di farlo comunque, leggere è sufficiente.

Vedi questo link , di seguito è riportato da lì:

BufferedReader è una class semplice pensata per leggere in modo efficiente dal stream secondario. Generalmente, ogni richiesta di lettura fatta da un Reader come un FileReader fa sì che venga eseguita una richiesta di lettura corrispondente al stream sottostante. Ogni chiamata di read () o readLine () potrebbe causare la lettura di byte dal file, la conversione in caratteri e la restituzione, che può essere molto inefficiente. L’efficienza è migliorata sensibilmente se un Reader è deformato in un BufferedReader.

BufferedReader è sincronizzato, quindi le operazioni di lettura su BufferedReader possono essere eseguite in modo sicuro da più thread.

D’altra parte uno scanner ha molto più formaggio incorporato; può fare tutto ciò che BufferedReader può fare e allo stesso livello di efficienza. Tuttavia, in aggiunta, uno scanner può analizzare il stream sottostante per tipi primitivi e stringhe utilizzando espressioni regolari. Può anche tokenizzare il stream sottostante con il delimitatore di tua scelta. Può anche fare in avanti la scansione del stream sottostante ignorando il delimitatore!

Uno scanner tuttavia non è thread-safe, deve essere sincronizzato esternamente.

La scelta di utilizzare un Buffered Reader o uno Scanner dipende dal codice che si sta scrivendo, se si sta scrivendo un semplice log reader Il lettore bufferizzato è adeguato. Tuttavia, se stai scrivendo un parser XML, Scanner è la scelta più naturale.

Anche durante la lettura dell’input, se si desidera accettare l’input dell’utente riga per riga e dire basta aggiungerlo a un file, BufferedReader è abbastanza buono. D’altra parte se si desidera accettare l’input dell’utente come un comando con più opzioni, e quindi si intende eseguire diverse operazioni in base al comando e alle opzioni specificate, uno scanner si adatta meglio.

  1. BufferedReader ha una memoria buffer significativamente più grande di Scanner. Utilizzare BufferedReader se si desidera ottenere stringhe lunghe da un stream e utilizzare Scanner se si desidera analizzare un tipo specifico di token da un stream.

  2. Scanner può utilizzare tokenize utilizzando delimitatore personalizzato e analizzare lo stream in tipi di dati primitivi, mentre BufferedReader può solo leggere e memorizzare String.

  3. BufferedReader è sincrono mentre Scanner non lo è. Usa BufferedReader se stai lavorando con più thread.

  4. Scanner nasconde IOException mentre BufferedReader lancia immediatamente.

Suggerisco di usare BufferedReader per leggere il testo. Scanner nasconde IOException mentre BufferedReader lancia immediatamente.

  • BufferedReader è sincrono mentre Scanner non lo è.
  • BufferedReader dovrebbe essere usato se stiamo lavorando con più thread.
  • BufferedReader ha una memoria buffer significativamente più grande di Scanner .
  • Lo Scanner ha un piccolo buffer (buffer di 1KB) in contrapposizione a BufferedReader (buffer di byte da 8 KB), ma è più che sufficiente.
  • BufferedReader è un po ‘più veloce rispetto allo Scanner perché Scanner analizza i dati di input e BufferedReader legge semplicemente la sequenza di caratteri.

================================================== ======================

La class Scanner è il complemento della class Formater (utilizzata per convertire i dati binari in testo formattato). Lo scanner legge l’input formattato e lo converte nel suo formato binario. Sebbene sia sempre stato ansible leggere l’input formattato, è stato necessario uno sforzo maggiore di quello che la maggior parte dei programmatori preferirebbe. Grazie all’aggiunta di Scanner, ora è facile leggere tutti i tipi di valori numerici, stringhe e altri tipi di dati, indipendentemente dal fatto che provengano da un file su disco, dalla tastiera o da un’altra fonte. Lo scanner può essere utilizzato per leggere l’input dalla console, un file, una stringa o qualsiasi altra fonte che implementa l’interfaccia leggibile o ReadableByteChannel. Ad esempio, è ansible utilizzare Scanner per leggere un numero dalla tastiera e assegnare il suo valore a una variabile.

BufferedReader , d’altra parte, è una class I / O stream di personaggi. I flussi di caratteri forniscono un modo conveniente per l’input e l’output in termini di caratteri (Unicode). BufferedReader è principalmente usato per prendere input dalla console, System.in . Prende un object InputStreamReader come argomento.

Le principali differenze:

  1. Scanner

  • Un semplice scanner di testo in grado di analizzare tipi e stringhe primitive utilizzando espressioni regolari.
  • Uno scanner interrompe il proprio input in token usando un pattern delimitatore, che per default corrisponde agli spazi bianchi. I token risultanti possono quindi essere convertiti in valori di tipi diversi usando i vari metodi successivi.

Esempio

  String input = "1 fish 2 fish red fish blue fish"; Scanner s = new Scanner(input).useDelimiter("\\s*fish\\s*"); System.out.println(s.nextInt()); System.out.println(s.nextInt()); System.out.println(s.next()); System.out.println(s.next()); s.close(); 

stampa il seguente risultato:

  1 2 red blue 

Lo stesso output può essere generato con questo codice, che utilizza un’espressione regolare per analizzare tutti e quattro i token contemporaneamente:

  String input = "1 fish 2 fish red fish blue fish"; Scanner s = new Scanner(input); s.findInLine("(\\d+) fish (\\d+) fish (\\w+) fish (\\w+)"); MatchResult result = s.match(); for (int i=1; i<=result.groupCount(); i++) System.out.println(result.group(i)); s.close(); ` 


  1. BufferedReader:

    • Legge il testo da un stream di input di caratteri, memorizzando i caratteri in modo da fornire una lettura efficiente di caratteri, matrici e linee.

    • La dimensione del buffer può essere specificata oppure è ansible utilizzare la dimensione predefinita. Il valore predefinito è abbastanza grande per la maggior parte degli scopi.

In generale, ogni richiesta di lettura fatta da un Reader provoca una corrispondente richiesta di lettura del carattere sottostante o del stream di byte. È quindi consigliabile avvolgere un BufferedReader attorno a qualsiasi Reader le cui operazioni read () potrebbero essere costose, come FileReader e InputStreamReader. Per esempio,

 BufferedReader in = new BufferedReader(new FileReader("foo.in")); 

bufferizzerà l'input dal file specificato. Senza il buffering, ogni invocazione di read () o readLine () potrebbe causare la lettura di byte dal file, la conversione in caratteri e la restituzione, che può essere molto inefficiente. I programmi che utilizzano DataInputStreams per l'input testuale possono essere localizzati sostituendo ogni DataInputStream con un BufferedReader appropriato.

Fonte: collegamento

Di seguito sono riportate le differenze tra BufferedReader e Scanner

  1. BufferedReader legge solo i dati ma lo scanner analizza anche i dati.
  2. puoi solo leggere String usando BufferedReader, ma puoi leggere int, long o float usando Scanner.
  3. BufferedReader è più vecchio da Scanner, esiste da jdk 1.1 mentre Scanner è stato aggiunto su JDK 5.
  4. La dimensione del buffer di BufferedReader è grande (8 KB) rispetto a 1 KB di scanner.
  5. BufferedReader è più adatto per la lettura di file con stringhe lunghe mentre Scanner è più adatto alla lettura di piccoli input da parte del prompt dei comandi.
  6. BufferedReader è sincronizzato ma Scanner non lo è, il che significa che non è ansible condividere lo Scanner tra più thread.
  7. BufferedReader è più veloce di Scanner perché non dedica tempo all’analisi
  8. BufferedReader è un po ‘più veloce rispetto allo Scanner
  9. BufferedReader è dal pacchetto java.io e Scanner è dal pacchetto java.util sulla base dei punti che possiamo selezionare la nostra scelta.

Grazie

La differenza tra BufferedReader e Scanner è la seguente:

  1. BufferedReader è sincronizzato ma Scanner non è sincronizzato .
  2. BufferedReader è thread-safe, ma Scanner non è thread-safe .
  3. BufferedReader ha una memoria buffer più grande ma Scanner ha una memoria buffer più piccola .
  4. BufferedReader è più veloce ma Scanner è più lento in esecuzione .
  5. Codice per leggere una riga dalla console:

    BufferedReader :

      InputStreamReader isr=new InputStreamReader(System.in); BufferedReader br= new BufferedReader(isr); String st= br.readLine(); 

    Scanner :

     Scanner sc= new Scanner(System.in); String st= sc.nextLine(); 

Ci sono diversi modi di prendere input in java come:

1) BufferedReader 2) Scanner 3) Argomenti della riga di comando

BufferedReader Legge il testo da un stream di input di caratteri, memorizzando i caratteri in modo da fornire una lettura efficiente di caratteri, matrici e linee.

Dove Scanner è un semplice scanner di testo che può analizzare tipi e stringhe primitive utilizzando espressioni regolari.

se stai scrivendo un semplice lettore di log il lettore tamponato è adeguato. se stai scrivendo un parser XML Scanner è la scelta più naturale.

Per maggiori informazioni si prega di consultare:

http://java.meritcampus.com/t/240/Bufferedreader?tc=mm69

La risposta sotto è presa da Reading dalla Console: JAVA Scanner vs BufferedReader

Quando si legge un input dalla console, esistono due opzioni per ottenerlo. Prima si usa Scanner , un altro usando BufferedReader . Entrambi hanno caratteristiche diverse. Significa differenze su come usarlo.

Scanner trattato come input dato come token. BufferedReader legge semplicemente riga dopo riga dato come stringa. Lo scanner fornisce autonomamente funzionalità di analisi come nextInt (), nextFloat ().

Ma quali sono le differenze tra gli altri?

  • Scanner trattato come input dato come token. BufferedReader come stream line / String
  • Scanner tokenized dato input usando regex. Utilizzando BufferedReader è necessario scrivere codice aggiuntivo
  • BufferedReader più veloce di Scanner * punto n. 2
  • Lo scanner non è sincronizzato, BufferedReader sincronizzato

Lo scanner viene fornito con la versione 1.5 di JDK in poi.

Quando utilizzare Scanner o Lettore bufferizzato?

Guarda le principali differenze tra entrambi, uno che usa tokenizzato, altri che usano la linea di stream. Quando sono necessarie funzionalità di analisi, utilizzare invece Scanner. Ma, sono più a mio agio con BufferedReader. Quando hai bisogno di leggere da un file, usa BufferedReader, perché usa buffer quando legge un file. Oppure puoi utilizzare BufferedReader come input per Scanner.

Elenco pochi …

java.util.Scanner class java.util.Scanner è un semplice scanner di testo in grado di analizzare tipi e stringhe primitivi. Utilizza internamente espressioni regolari per leggere diversi tipi.

Java.io.BufferedReader class Java.io.BufferedReader legge il testo da un stream di input di caratteri, bufferizzando i caratteri in modo da fornire una lettura efficiente della sequenza di caratteri

1) BufferedReader è sincrono mentre Scanner non lo è. BufferedReader dovrebbe essere usato se stiamo lavorando con più thread.

2) BufferedReader ha una memoria buffer significativamente più grande di Scanner . Lo Scanner ha un piccolo buffer (buffer di 1KB) in contrapposizione a BufferedReader (buffer di byte da 8 KB), ma è più che sufficiente.

3) BufferedReader è un po ‘più veloce rispetto allo Scanner perché Scanner analizza i dati di input e BufferedReader legge semplicemente la sequenza di caratteri.

  1. BufferedReader probabilmente ti darà prestazioni migliori (perché Scanner è basato su InputStreamReader, guarda fonti). ups, per leggere dai file usa nio. Quando ho testato le prestazioni di nio contro le prestazioni di BufferedReader per i file di grandi dimensioni, nio mostra prestazioni leggermente migliori.
  2. Per leggere dal file prova Apache Commons IO.

Preferisco Scanner perché non genera eccezioni controllate e quindi il suo utilizzo risulta in un codice più snello.