Java scanner class

Java Scanner class
Scanner class belongs to java.util package and its primary use is to take user input in java. This class has methods which are used to take input of different data types directly from keyboard or console.

It means that a scanner object can be used to read an integer, character, boolean, double or a string input directly unlike other methods of taking user input in java which always read input as a string and then convert it to the required data type.
This article will explain how to use scanner in java along with examples of different methods of this class.

Using Java scanner
java.util.Scanner is widely used for reading user input due to the ease of its object creation and the flexibility it provides when taking input.

A scanner can read input from different sources such as an inputstream, a string, file or console input. It breaks the input read from any of these sources based on a delimiter into tokens and these tokens are then read using various methods.
Default delimiter is a white space but it can be changed with a useDelimiter method.

Example, if a scanner object reads a string “Learning java scanner”, then it will be broken into tokens “Learning”, “java” and “scanner” which can be read using its next method.
Java scanner syntax
An object of Scanner class can be created using its constructor. To read input from keyboard, we need to use the constructor that accepts an inputstream as argument as shown below

System.in returns an inputstream that is linked to standard input(keyboard).

Once the scanner is initialized, you can use its methods to read input of different data types. Since scanner class belongs to java.util package, we need to import scanner before using it.

Before looking at the example of using scanner, first understand its commonly used methods explained below.

Java scanner methods
Following are the important methods of scanner class.

Note: All the next methods above also have an overloaded version that takes an int as argument which is the radix to convert the values from String.

Java scanner example
Below program shows how java scanner class can be used to read input of multiple types from the user.

import java.util.Scanner; 

public class ScannerExample { 
  public static void main(String[] args) { 
    Scanner scanner = new Scanner(System.in); 
    System.out.println("Enter the food item"); 
    // read a single string word 
    String food = scanner.next(); 
    System.out.println("Enter quantity"); 
    // read an integer 
    int quantity = scanner.nextInt(); 
    System.out.println("Enter a comment"); 
    // NOTICE THIS 
    scanner.nextLine(); 
    // read an entire line 
    String comment = scanner.nextLine(); 
    scanner.close(); 
    // display the values read 
    System.out.println("Food: " + food); 
    System.out.println("Quantity: " + quantity); 
    System.out.println("Comment: " + comment); 
  } 
}

Above program takes as input a single string, an integer and an entire line or multiple word input from the user using its next(), nextInt() and nextLine() methods respectively and then displays the values entered.

Output of above program is

Close Java scanner
A scanner should be closed after its use with close() method.
Calling close() multiple times will close it only once and will not raise any error. Also, using the scanner for any operation after close() has been called, will raise an IllegalStateException.
Java scanner string input example
Below program creates a scanner with a string as its input rather than reading from console. This example will mainly demonstrate the use of hasNext() and next() methods.

import java.util.Scanner; 

public class ScannerString { 
  public static void main(String[] args) { 
    // create a scanner object 
    Scanner scanner = new Scanner("Learning how to use scanner"); 
    // iterate over tokens 
    while(scanner.hasNext()) { 
      // get the next token 
      String token = scanner.next(); 
      System.out.println(token); 
    } 
    // close scanner 
    scanner.close(); 
  } 
}

As mentioned earlier, the default delimiter of scanner is a whitespace. Thus, above example creates a scanner with a string as input which consists of multiple words separated by a space.
The scanner breaks its input based on this delimiter and each word becomes its token. We can get these tokens by iterating over the scanner using a while loop.
In every iteration, scanner checks for the presence on a token with its hasNext method and returns the token using its next() method.
Output of above program is

Java scanner file input example
A scanner can also be used to read a file. It has a constructor that takes a java.io.File object as argument which points to a physical file on the system.
Once you create an object of scanner, it can be used to read the file contents using its hasNext() and next() methods where hasNext() will return true till there is some content to read in the file.
Since the default delimiter is a whitespace, next() method will return each word that is separated by a space on both sides.

import java.io.File; 
import java.io.FileNotFoundException; 
import java.util.Scanner; 

public class ScannerFileExample { 
  public static void main(String[] args) { 
    try { 
      // create a scanner object 
      Scanner scanner = new Scanner(new File("e:/demo.txt")); 
      // iterate over tokens 
      while(scanner.hasNext()) { 
        // get the next token 
        String token = scanner.next(); 
        System.out.println(token); 
      } 
      // close scanner 
      scanner.close(); 
    } catch (FileNotFoundException e) { 
      e.printStackTrace(); 
    } 
  } 
}

Assuming that the file contents are as below,

the output of above program will be

Notice that the scanner class constructor that takes a file object as argument throws a java.io.FileNotFoundException since the file may or may not exist.
You need to catch or throw the exception. This is a part of exception handling concept in java.
Java scanner with modified delimiter
It might also happen that you do not want to split the scanner input into tokens on a whitespace but on a different delimiter.
Below example will show how to use a different delimiter to get tokens from the scanner contents.

import java.util.Scanner; 

public class ScannerDelimiter { 
  public static void main(String[] args) { 
    // create a scanner object 
    Scanner scanner = new Scanner("Learning##how##to##use##scanner"); 
    // change the delimiter 
    scanner.useDelimiter("##"); 
    // iterate over tokens 
    while(scanner.hasNext()) { 
      // get the next token 
      String token = scanner.next(); 
      System.out.println(token); 
    } 
    // close scanner scanner.close(); 
  } 
}

Above example changes the scanner’s delimiter to a “##” and tokenizes the content based on this pattern. Output will be

If you look carefully, this works similar to split method of String class where a string is divided based on some pattern.
Hope this post was useful for you. Hit the clap if it was helpful.