Java Scanner hasNextInt() Method

The hasNextInt() method in Java, part of the java.util.Scanner class, is used to check if the next token in the Scanner input can be interpreted as an int. There are also overloaded versions of this method to check for an int in a specific radix (base).

Table of Contents

1. Introduction
2. hasNextInt() Method Syntax
3. Understanding hasNextInt()
4. Examples
   • Basic Usage
   • Using a Custom Radix
5. Real-World Use Case
6. Conclusion

Introduction

The hasNextInt() method checks if the next token in the Scanner input can be interpreted as an int. This method is useful for parsing integer values from input data while ensuring that the input is valid.

hasNextInt() Method Syntax

There are two versions of the hasNextInt() method:

Default Radix

public boolean hasNextInt()

Custom Radix

public boolean hasNextInt(int radix)

Parameters:

• radix: The radix (base) to be used for interpreting the token as an integer.

Returns:

• true if the next token can be interpreted as an int; false otherwise.

Throws:

• IllegalStateException: If the scanner is closed.
• InputMismatchException: If the next token is not a valid int.

Understanding hasNextInt()

The hasNextInt() method checks if the next token in the input can be parsed as an integer. If it returns true, the next call to nextInt() will successfully retrieve the integer value. If it returns false, the next token is not a valid integer, and calling nextInt() would throw an InputMismatchException.

Examples

Basic Usage

To demonstrate the basic usage of hasNextInt(), we will create a Scanner object and check if the next token can be parsed as an integer.

Example

import java.util.Scanner;

public class HasNextIntExample {
    public static void main(String[] args) {
        String input = "123 456 abc";

        // Create Scanner object in try-with-resources to ensure it closes automatically
        try (Scanner scanner = new Scanner(input)) {

            while (scanner.hasNext()) {
                if (scanner.hasNextInt()) {
                    System.out.println("Found an integer: " + scanner.nextInt());
                } else {
                    System.out.println("Found a non-integer token: " + scanner.next());
                }
            }
        } // Scanner is automatically closed here
    }
}

Output:

Found an integer: 123
Found an integer: 456
Found a non-integer token: abc

Using a Custom Radix

This example shows how to use hasNextInt(int radix) to check for integers in a specific radix (base).

Example

import java.util.Scanner;

public class HasNextIntWithRadixExample {
    public static void main(String[] args) {
        String input = "1010 10 2";

        // Create Scanner object in try-with-resources to ensure it closes automatically
        try (Scanner scanner = new Scanner(input)) {

            while (scanner.hasNext()) {
                if (scanner.hasNextInt(2)) { // Check for binary numbers (base 2)
                    System.out.println("Found a binary integer: " + scanner.nextInt(2));
                } else {
                    System.out.println("Found a non-binary token: " + scanner.next());
                }
            }
        } // Scanner is automatically closed here
    }
}

Output:

Found a binary integer: 10
Found a binary integer: 2
Found a non-binary token: 2

Real-World Use Case

Parsing Configuration Files

In real-world applications, the hasNextInt() method can be used to parse configuration files where integer values need to be extracted and validated.

Example

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

public class ConfigParser {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(new File("config.txt"))) {
            while (scanner.hasNext()) {
                if (scanner.hasNextInt()) {
                    int value = scanner.nextInt();
                    System.out.println("Config value: " + value);
                } else {
                    scanner.next(); // Skip non-integer tokens
                }
            }
        } catch (FileNotFoundException e) {
            System.out.println("Config file not found: " + e.getMessage());
        }
    }
}

Output (Assuming config.txt contains integers and other tokens):

Config value: 42
Config value: 100

Conclusion

The Scanner.hasNextInt() method and its overloaded version with a custom radix provide a way to check for the presence of the next token in the input that can be interpreted as an integer. By understanding and using these methods, you can efficiently parse and validate integer values from input data. 

Whether you are working with default or custom radices, the hasNextInt() method offers a reliable way to handle integer presence checks in your Java applications. Always remember to close the Scanner using try-with-resources to ensure proper resource management.