Question

Well, this might be a silly problem.

I just want a faster implementation of following problem

I want to take three integer input in a single line eg:

10 34 54

One way is to make a BufferedReader and then use readLine()
which will read the whole line as a string
then we can use StringTokenizer to separate three integer. (Slow implemetation)

Another way is to use ‘Scanner’ and take input by nextInt() method. (Slower than previous method)

I want a fast implementation to take such type of inputs since I have to read more than 2,000,000 lines and these implementations are very slow.

My implementation:

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

for(i=0;i<n;i++) {
    str=br.readLine();
    st = new StringTokenizer(str);
    t1=Integer.parseInt(st.nextElement().toString());
    t2=Integer.parseInt(st.nextElement().toString());
    z=Long.parseLong(st.nextElement().toString());
}

This one is looped for n times. ( n is number of entries)
Since I know each line will contain only three integer there is no need to check for hasMoreElements()

Answer 1

I just want a faster implementation of following problem.

The chances are that you DON’T NEED a faster implementation. Seriously. Not even with a 2 million line input file.

The chances are that:

• more time is spent processing the file than reading it, and
• most of the “read time” is spent doing things at the operating system level, or simply waiting for the next disk block to be read.

My advice is to not bother optimizing this unless the application as a whole takes too long to run. And when you find that this is the case, profile the application, and use the profile stats to tell you where it could be worthwhile spending effort on optimization.

(My gut feeling is that there is not much to be gained by optimizing this part of your application. But don’t rely on that. Profile it!)