Thread: Reuse same Scanner to read another file

The reset() method will reset the value of the scanner's radix to 10 regardless of whether it was previously changed. (ref)

Does your program work or what is the error message?

Thought it would be good practice to use the same Scanner if possible instead of creating another object, I used it initially to count the number of items in the File to use this count as the array size to store the file contents in, then I wanted to go back to the beginning of the file to start reading in again this time storing the file contents in the array.

In fact reset() is true to label and "discards all of its explicit state information". So not just radix, but locale and delimeter pattern are zapped.

Don't use reset() unless you really mean that to happen. If the Scanner instance reads (or might be reading) a file, then a case could be made for calling close() when you've finished reading the file as this is designed to release any system resources that might be being used. (Your program shares these resources with other things going on on the computer, so it's polite to free them as soon as possible.)

In general the wisdom is that "object creation is cheap". But when people say that they are talking about zillions of objects (and then they make exceptions in the case of creating mega-zillions). In your case the cost of creating one or two new objects is a few nanoseconds and a few bytes at most. Moreover when we think about the time cost, it's the slowest part of the operation that counts. Compared with computation, reading a file from disk is s-l-o-w. And reading user typed information from the console is unbelievably slow. So the few nanoseconds you might save on object creation is swamped by the millions of nanoseconds it takes the user to figure out where they put the "J" on the keyboard.

ns.reset();
x = 0;
ns = Scanner(new File(file2)); // should be ns = new Scanner(new File(file2));

Notice that this code *does* create a new scanner (if corrected). It's just the variable ns that is reused. A brand new scanner is created, so the previous call to reset() resets a completely different scanner and, from your program's point of view, that does nothing at all.

Be careful where you declare variables. ns is declared in a try block and will only be visible within that block. This is true for any Java variable: if you declare a variable it goes out of scope and becomes "invisible" once you hit the } ending the block where it was declared.

Thought reset() would allow the scanner to start reading the file again from start. Now know I know even less than I thought I did. I don't need the scanner visible outside the try block, only using it there to read the file and fill the array which has been originally declared outside the block. Just wanted to know if I can make the same scanner start reading the file again or do I need a new scanner (was leaving out the new as it already created).

Thought reset() would allow the scanner to start reading the file again from start.

No. It resets state like the what counts as delimiter between the ints (which you are not using). But it doesn't affect the position of the scanner within the stream. So if you reset() then keep reading you will be reading from where you left off (-1 or end of file) not from the start of the file.

By far the easiest way to start reading the file again is to create a new Scanner.

The use of the name "reset" for this functionality could be a little bit confusing because if you reset() a BufferedReader it really does go back to the start. This means that you *can* reuse a Scanner instance if you really, really want to. But, I repeat, it is much easier not to.

To illustrate this I put a file containing "1 2 3 4 5 5 4 3 2 -1 1" in c:\temp\temp.txt and ran the following code:

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;
 
public class ScannerTest {
    public static void main(String[] args) throws IOException {
        test1();
        test2();
    }
 
    static void test1() throws FileNotFoundException {
        Scanner in = new Scanner(new File("c:/temp/temp.txt"));
 
        int count = 0;
        while(in.hasNextInt() && in.nextInt() != -1) {
            count++;
        }
        System.out.println(count + " ints found");
 
        in.reset();
        System.out.println(in.nextLine());
 
        in.close();
    }
 
    static void test2() throws IOException {
        BufferedReader br = new BufferedReader(new FileReader("c:/temp/temp.txt"));
        br.mark(100000); // <-- mark the start of the underlying reader
        Scanner in = new Scanner(br);
 
        int count = 0;
        while(in.hasNextInt() && in.nextInt() != -1) {
            count++;
        }
        System.out.println(count + " ints found");
 
        br.reset(); // <-- reset the underlying reader, not the scanner
        System.out.println(in.nextLine());
 
        in.close();
    }
 
}

The output is

9 ints found
 1
9 ints found
 11 2 3 4 5 5 4 3 2 -1 1

The first two lines output show how resetting the Scanner had no effect on its position. The second two show that calling reset() on the underlying BufferedReader allowed content from the beginning to be read again. (although you get a junk character already buffered by the reader).

I don't need the scanner visible outside the try block

My mistake, I see that now the code is formatted.