Java Scanner Tutorial with Examples

The java.util is the utilities package in Java that contains classes and utilities for actions like date/time manipulation, number randomization and storing and processing large amounts of data. One of its classes is Scanner; an instantiable class that reads/scans text from a source and parses it to a primitive or a string using regular expressions. Scanner can read from different sources like the default’s System.in (typically the user’s keyboard) or a text file in disk. Before instantiation we must specify the source of the Scanner object; e.g. new Scanner(System.in) or new Scanner(new File("d:\\data\\myFile.txt")).

Using the Scanner to read from the keyboard

The following sample application creates a Scanner object and sets the source to be the user’s keyboard (System.in). Then we allow the user to start typing a sentence and wait for ENTER to capture the data.

package com.rib.samples.scanner;

import java.util.Scanner;

/*
Author: Gustavo Luque
ReadingInBits, 2020
*/
public class ScannerExample {

    public static void main(String[] args) {
        ScannerExample app = new ScannerExample();
        app.readStuff();
    }

    private void readStuff(){
        Scanner scanner = new Scanner(System.in);
        System.out.print("Type in your full name: ");
        String name = scanner.nextLine();
        System.out.println(String.format("Welcome %s!", name));
    }
}

On line 19, we use nextLine() to advance the scanner pointer past the next line and return the skipped input, which in this case is the line of text typed in by the user followed by an ENTER.

Scanner can also break an input text into different tokens using the default’s delimiter (whitespace). Each token may be converted to a primitive value using the corresponding token-reader method. E.g., let’s modify our readStuff() method to make it read an int using the token-reader method nextInt():

private void readStuff(){
    System.out.print("Enter an integer value: ");
    try{
        int value = scanner.nextInt();
        System.out.println(String.format("%d! = %d", value, getFactorial(value)));
    }catch (InputMismatchException ime){
        System.err.println("number is not an integer.");
    }
}

private int getFactorial(int v){
    if(v > 0){
        int result = 1;
        for (int i = 1; i <= v; i++){
            result *= i;
        }
        return result;
    }
    return 1;
}

Basically, the program waits for the ENTER to read the token and translate it to an integer primitive, then we use the value to calculate its factorial (blah, blah, blah).

Using a different delimiter

Scanner may also use an explicit delimiter to parse the keyboard’s text entry.

private void readStuff(){

        Scanner scanner = new Scanner(System.in);
        Scanner sumScanner = null;

        try{

            System.out.print("Enter the sum expression: ");
            String expression = scanner.nextLine();

            sumScanner = new Scanner(expression).useDelimiter("\\+");
            int sum = sumScanner.nextInt() + sumScanner.nextInt();
            System.out.println(String.format("Sum is %d", sum));

        }catch (InputMismatchException ime) {
            System.err.println(ime.getMessage());
        }catch (Exception ex){
            System.err.println("Unexpected: " + ex.toString());
        }finally {
            if(sumScanner != null)
                sumScanner.close();
            if(scanner != null)
                scanner.close();
        }
    }

In order to show the capabilities of Scanner‘s userDelimiter() method, in the example above, we use two scanner objects; one to read the line of text (sum expression) entered, and the second to use the string as the source and the + char as the delimiter to parse the expression. Finally, we extract the two tokens to convert them into integers and sum the up (line 11). We also use a finally clause to ensure that the system resources get closed.

More token-readers (methods) from Scanner

Method	Description
`nextBigDecimal()`	Scans the next token from the input and converts it to `BigDecimal`
`nextBigInteger()`	Scans the next token from the input and converts it to `BigInteger`
`nextBoolean()`	Scans the next token from the input and converts it to `Boolean`
`nextByte()`	Scans the next token from the input and converts it to `Byte`
`nextDouble()`	Scans the next token from the input and converts it to `Double`
`nextFloat()`	Scans the next token from the input and converts it to `Float`
`nextInt()`	Scans the next token from the input and converts it to `Int`
`nextLong()`	Scans the next token from the input and converts it to `Long`
`nextShort()`	Scans the next token from the input and converts it to `Short`

Using the Scanner to read from a file

Another interesting way to use the Scanner class is definitely the file processing. We simply set the source to be a File instance with the path to the file to read, then use one of the methods availbale to do the data manipulation. In the following example, we will read the file located at D:\data\employees.xml to read and extract each tag firstName value per employee and print the result. The file is an XML, so we should be thinking of utilizing a string pattern to make the data extraction. Let’s hop right in:

private void readStuff(){
        Scanner fileScanner = null;
        try {
            Scanner scanner = new Scanner(new File("D:\\data\\employees.xml"));
            String pattern = "\\<firstName\\>\\w+\\</firstName\\>";
            while (scanner.hasNext()){
                if(scanner.hasNext(pattern)){
                    System.out.println(scanner.next(pattern));
                    continue;
                }

                scanner.next();
            }
        }catch (IOException ex){
            System.err.println("Unexpected: " + ex.toString());
        }finally {
            //We close the scanner resource
            if(fileScanner != null)
                fileScanner.close();
        }
    }

On line 4 we define a new Scanner object and set the File instance as its source. Then we define a pattern to match the tag that we want to read per employee in the XML file. In order to achieve this we can use the hasNext() method and its variation (with a string pattern). So, lines 8-15 define a while loop to ask the scanner whether the file has more tokens to be read. If so, we ask if the token matches the pattern we set on line 7 (here’s a brief reference on regular expressions); and if that’s the case we make the scanner object return the corresponding token by using scanner.next(pattern). Else, we move to the next token and continue the scanning process. Again, we make sure we close the scanner instance to release system resources on line 21. The program’s output would look similar to this:

Conclusion

Scanner comes in really handy whenever we need to read and process data from a specific source. Its string-pattern-match capabilities enables a program to not only read tokens of data, but also to string-manipulate the data using regular expressions. If you want to learn more about the Java API documentation (Java SE 8) for this class you can take a look here.