Scanner vs. BufferedReader
-
19-09-2019 - |
Question
As far I know, the two most common methods of reading character-based data from a file in Java is using Scanner
or BufferedReader
. I also know that the BufferedReader
read files efficiently by using a buffer to avoid physical disk operations. My questions are:
- Does
Scanner
performs as well asBufferedReader
? - Why would you choose
Scanner
overBufferedReader
or vice versa?
Solution
Scanner
is used for parsing tokens from the contents of the stream while BufferedReader
just reads the stream and does not do any special parsing.
In fact you can pass a BufferedReader
to a scanner
as the source of characters to parse.
OTHER TIPS
In currently latest JDK6 release/build (b27), the Scanner
has a smaller buffer (1024 chars) as opposed to the BufferedReader
(8192 chars), but it's more than sufficient.
As to the choice, use the Scanner
if you want to parse the file, use the BufferedReader
if you want to read the file line by line. Also see the introductory text of their aforelinked API documentations.
- Parsing = interpreting the given input as tokens (parts). It's able to give back you specific parts directly as int, string, decimal, etc. See also all those
nextXxx()
methods inScanner
class. - Reading = dumb streaming. It keeps giving back you all characters, which you in turn have to manually inspect if you'd like to match or compose something useful. But if you don't need to do that anyway, then reading is sufficient.
See this link, following is quoted from there:
A BufferedReader is a simple class meant to efficiently read from the underling stream. Generally, each read request made of a Reader like a FileReader causes a corresponding read request to be made to underlying stream. Each invocation of read() or readLine() could cause bytes to be read from the file, converted into characters, and then returned, which can be very inefficient. Efficiency is improved appreciably if a Reader is warped in a BufferedReader.
BufferedReader is synchronized, so read operations on a BufferedReader can safely be done from multiple threads.
A scanner on the other hand has a lot more cheese built into it; it can do all that a BufferedReader can do and at the same level of efficiency as well. However, in addition a Scanner can parse the underlying stream for primitive types and strings using regular expressions. It can also tokenize the underlying stream with the delimiter of your choice. It can also do forward scanning of the underlying stream disregarding the delimiter!
A scanner however is not thread safe, it has to be externally synchronized.
The choice of using a BufferedReader or a Scanner depends on the code you are writing, if you are writing a simple log reader Buffered reader is adequate. However if you are writing an XML parser Scanner is the more natural choice.
Even while reading the input, if want to accept user input line by line and say just add it to a file, a BufferedReader is good enough. On the other hand if you want to accept user input as a command with multiple options, and then intend to perform different operations based on the command and options specified, a Scanner will suit better.
BufferedReader
has significantly larger buffer memory than Scanner. UseBufferedReader
if you want to get long strings from a stream, and useScanner
if you want to parse specific type of token from a stream.Scanner
can use tokenize using custom delimiter and parse the stream into primitive types of data, whileBufferedReader
can only read and store String.BufferedReader
is synchronous whileScanner
is not. UseBufferedReader
if you're working with multiple threads.Scanner
hides IOException whileBufferedReader
throws it immediately.
I suggest to use BufferedReader
for reading text. Scanner
hides IOException
while BufferedReader
throws it immediately.
Difference between BufferedReader and Scanner are following:
- BufferedReader is synchronized but Scanner is not synchronized.
- BufferedReader is thread safe but Scanner is not thread safe.
- BufferedReader has larger buffer memory but Scanner has smaller buffer memory.
- BufferedReader is faster but Scanner is slower in execution.
Code to read a line from 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();
Following are the differences between BufferedReader and Scanner
- BufferedReader only read data but scanner also parse data.
- you can only read String using BufferedReader, but you can read int, long or float using Scanner.
- BufferedReader is older from Scanner,it exists from jdk 1.1 while Scanner was added on JDK 5 release.
- The Buffer size of BufferedReader is large(8KB) as compared to 1KB of Scanner.
- BufferedReader is more suitable for reading file with long String while Scanner is more suitable for reading small user input from command prompt.
- BufferedReader is synchronized but Scanner is not, which means you cannot share Scanner among multiple threads.
- BufferedReader is faster than Scanner because it doesn't spent time on parsing
- BufferedReader is a bit faster as compared to Scanner
- BufferedReader is from java.io package and Scanner is from java.util package on basis of the points we can select our choice.
Thanks
The Main Differences:
- Scanner
- A simple text scanner which can parse primitive types and strings using regular expressions.
- A Scanner breaks its input into tokens using a delimiter pattern, which by default matches whitespace. The resulting tokens may then be converted into values of different types using the various next methods.
Example
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();
prints the following output:
1
2
red
blue
The same output can be generated with this code, which uses a regular expression to parse all four tokens at once:
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(); `
BufferedReader:
Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
The buffer size may be specified, or the default size may be used. The default is large enough for most purposes.
In general, each read request made of a Reader causes a corresponding read request to be made of the underlying character or byte stream. It is therefore advisable to wrap a BufferedReader around any Reader whose read() operations may be costly, such as FileReaders and InputStreamReaders. For example,
BufferedReader in
= new BufferedReader(new FileReader("foo.in"));
will buffer the input from the specified file. Without buffering, each invocation of read() or readLine() could cause bytes to be read from the file, converted into characters, and then returned, which can be very inefficient. Programs that use DataInputStreams for textual input can be localized by replacing each DataInputStream with an appropriate BufferedReader.
Source:Link
There are different ways of taking input in java like:
1) BufferedReader 2) Scanner 3) Command Line Arguments
BufferedReader Read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
Where Scanner is a simple text scanner which can parse primitive types and strings using regular expressions.
if you are writing a simple log reader Buffered reader is adequate. if you are writing an XML parser Scanner is the more natural choice.
For more information please refer:
The answer below is taken from Reading from Console: JAVA Scanner vs BufferedReader
When read an input from console, there are two options exists to achieve that. First using Scanner
, another using BufferedReader
. Both of them have different characteristics. It means differences how to use it.
Scanner treated given input as token. BufferedReader just read line by line given input as string. Scanner it self provide parsing capabilities just like nextInt(), nextFloat().
But, what is others differences between?
- Scanner treated given input as token. BufferedReader as stream line/String
- Scanner tokenized given input using regex. Using BufferedReader must write extra code
- BufferedReader faster than Scanner *point no. 2
- Scanner isn’t synchronized, BufferedReader synchronized
Scanner come with since JDK version 1.5 higher.
When should use Scanner, or Buffered Reader?
Look at the main differences between both of them, one using tokenized, others using stream line. When you need parsing capabilities, use Scanner instead. But, i am more comfortable with BufferedReader. When you need to read from a File, use BufferedReader, because it’s use buffer when read a file. Or you can use BufferedReader as input to Scanner.
BufferedReader will probably give you better performance (because Scanner is based on InputStreamReader, look sources).ups, for reading from files it uses nio. When I tested nio performance against BufferedReader performance for big files nio shows a bit better performance.- For reading from file try Apache Commons IO.
I prefer Scanner
because it doesn't throw checked exceptions and therefore it's usage results in a more streamlined code.