Java Scanner: A Complete Guide for Effective Input Handling

Explore the ins and outs of Java Scanner – from diverse constructors to a multitude of methods. Delve into examples, compare Scanner vs BufferedReader, and grasp FAQs and vital considerations.

What is a Java Scanner?

The Scanner class in Java is part of the java.util package. It is a tool for breaking down input into meaningful tokens. A token can be a single word, a number, or even a special character. The Scanner class can identify different types of tokens and convert them into appropriate data types.

A Java Scanner is like a smart detective that helps your program read different types of information, such as text or numbers, from various sources like the keyboard or files. It breaks down the input into smaller parts, making it easier for your program to understand and use the information.

Think of a Java Scanner as a listener that hears what someone types on the computer and helps your program understand it. It can be used in many situations, like when you want someone to type their name, a number, or even a sentence, and your program needs to do something with that information. For example, if you’re making a calculator, the Scanner can listen to the numbers someone types and do the math. Or if you’re making a chatbot, the Scanner can listen to what a person types and respond based on that. It’s handy whenever you need your program to interact with someone typing things in.

Java Scanner Use Cases

Here are a few situations where Java Scanner can be useful:

1. User Input: Taking inputs from a user during a program’s execution, like asking for a name, age, or any information required for the program to proceed.
2. File Reading: Extracting information from files, such as reading a text file to process its contents.
3. Data Parsing: Breaking down a string of text or data into smaller parts, like separating words or numbers from a sentence.
4. Tokenization: Analyzing input and splitting it into individual pieces or tokens for further processing, like breaking down a sentence into words.
5. Menu Selection: For programs with menus where users make choices by inputting a number or specific keywords.
6. Data Validation: Verifying if the input matches certain criteria, like ensuring an entered value is a number or within a specific range.
7. Simple Games: Creating text-based games where players input commands or choices to progress.
8. Database Interaction: When creating programs that read input to query databases or store information.

Creating a Scanner Object

A Java scanner can be created by passing an input source to its constructor. The input source can be a System.in object, which represents the standard input stream, a File object, which represents a file on the disk, or a String object, which represents a string literal.

For example, to create a scanner that reads from the user input, we can write:

Scanner sc = new Scanner(System.in); // Create a scanner object

To create a scanner that reads from a file, we can write:

File file = new File("input.txt"); // Create a file object
Scanner sc = new Scanner(file); // Create a scanner object

To create a scanner that reads from a string, we can write:

String str = "Hello, world!"; // Create a string object
Scanner sc = new Scanner(str); // Create a scanner object

How to Use Java Scanner Methods?

A Java scanner provides various methods to read and parse different types of data from the input source. Some of the most commonly used methods are:

• next(): This method returns the next token as a String object. It only reads until the first delimiter, so it can be used to read a single word from the input.

• nextLine(): This method returns the next line of input as a String object. It reads until the end of the line, so it can be used to read a whole sentence or paragraph from the input.

• nextInt(): This method returns the next token as an int value. It parses the token as an integer, so it can be used to read a numerical value from the input. It throws an InputMismatchException if the token cannot be parsed as an integer.

• nextDouble(): This method returns the next token as a double value. It parses the token as a double-precision floating-point number, so it can be used to read a decimal value from the input. It throws an InputMismatchException if the token cannot be parsed as a double.

Similarly, there are other methods to read and parse other primitive data types, such as nextBoolean(), nextByte(), nextFloat(), nextLong(), and nextShort().

Example: Let’s consider a scenario of a job application where a candidate’s details are collected using Scanner methods:

import java.util.Scanner;

public class JobApplication {
    public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in); // Create a scanner object

        System.out.println("Welcome! Please enter your details for the job application:");

        // Name input
        System.out.print("Enter your full name: ");
        String name = scanner.nextLine();

        // Age input
        System.out.print("Enter your age: ");
        int age = scanner.nextInt();

        // Salary expectation input
        System.out.print("Enter your expected salary: ");
        double salary = scanner.nextDouble();

        // Boolean - Relocation availability input
        System.out.print("Are you open to relocation? (true/false): ");
        boolean willingToRelocate = scanner.nextBoolean();

        // Byte - Years of experience input
        System.out.print("Years of professional experience: ");
        byte yearsOfExperience = scanner.nextByte();

        // Float - GPA input
        System.out.print("Enter your GPA: ");
        float gpa = scanner.nextFloat();

        // Long - Contact number input
        System.out.print("Enter your contact number: ");
        long contactNumber = scanner.nextLong();

        // Short - Number of languages spoken
        System.out.print("How many languages do you speak? (0-32767): ");
        short languagesSpoken = scanner.nextShort();

        // Output candidate's entered details
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Salary Expectation: " + salary);
        System.out.println("Willing to Relocate: " + willingToRelocate);
        System.out.println("Years of Experience: " + yearsOfExperience);
        System.out.println("GPA: " + gpa);
        System.out.println("Contact Number: " + contactNumber);
        System.out.println("Languages Spoken: " + languagesSpoken);

        scanner.close(); // Close the scanner
    }
}

Output:

Java Scanner Methods Example Output

Java Scanner Methods

Below is the table detailing the various methods available in the Java Scanner class for handling different types of input.

How to Check the Input Type and Availability?

Sometimes, we may want to check the type and availability of the next input before reading it. For example, we may want to check if the input has ended, or if the next input is of a certain type. For this purpose, we can use the hasNext() and hasNextXYZ() methods, where XYZ is the type we are interested in.

The hasNext() method returns true if there is another token in the input and false otherwise. The hasNextXYZ() method returns true if the next token can be parsed as a value of type XYZ, and false otherwise. For example, hasNextInt() returns true if the next token can be parsed as an int value, and false otherwise.

Let’s consider a scenario where we want to analyze and process a sequence of user inputs that include different types of data like strings, integers, and decimals. For this, the below Java program processes a user-entered sequence of integers, doubles, or words. Upon encountering the input “exit”, it stops the input loop and calculates the sum of integers, the count of integers, the average of doubles, and the count of non-numeric inputs, displaying the collected data.

import java.util.Scanner;

public class DataProcessingExample {
    public static void main(String[] args) {
    
        Scanner scanner = new Scanner(System.in); // Create a scanner object
        
        int intSum = 0, intCount = 0;
        double doubleSum = 0.0;
        int doubleCount = 0;
        int stringCount = 0;

        System.out.println("Enter a sequence of integers, doubles, or words (enter 'exit' to finish):");

        while (scanner.hasNext()) { // Check if there is another token
            if (scanner.hasNextInt()) { // Check if the next input is an integer
                intSum += scanner.nextInt(); // Add integer to the sum
                intCount++; // Increment the count for integers
            } else if (scanner.hasNextDouble()) { // Check if the next input is a double
                doubleSum += scanner.nextDouble(); // Add double to the sum
                doubleCount++; // Increment the count for doubles
            } else {
                String input = scanner.next(); // Read the input as a String
                if (input.equalsIgnoreCase("exit")) {
                    break; // Exit the loop if the input is 'exit'
                }
                stringCount++; // Increment the count for other inputs
            }
        }

        System.out.println("Sum of integers: " + intSum); // Print the sum of integers
        System.out.println("Count of integers: " + intCount); // Print the count of integers
        System.out.println("Average of doubles: " + (doubleSum / doubleCount)); // Calculate and print the average of doubles
        System.out.println("Count of words: " + stringCount); // Print the count of words

        // Close the scanner (optional for the program to end)
        scanner.close(); // Close the scanner
    }
}

// Input
Enter a sequence of integers, doubles, or words (enter 'exit' to finish):
5 10.5 test 8 4 12.7 end exit

// Output
Sum of integers: 17
Count of integers: 3
Average of doubles: 11.6
Count of words: 2

Handling Exceptions with Scanner in Java

In Java, the Scanner class provides built-in error-handling mechanisms to manage exceptions that might occur during input operations. These exceptions are a part of Java’s standard exception hierarchy and are crucial for ensuring smooth and robust program execution.

When using Scanner methods like nextInt(), nextDouble(), or nextLine(), various issues could arise while interpreting input. The Scanner class handles these potential issues through two primary exceptions:

1. InputMismatchException: This exception is triggered when the Scanner encounters input that doesn’t match the expected data type. For instance, if you’re trying to read an integer but the input is not a valid number, an InputMismatchException is raised.
2. NoSuchElementException: This exception occurs when a Scanner method is used but there’s no more input to read. For instance, if you’re trying to fetch the next token in the input but there isn’t anything left, a NoSuchElementException is thrown.

To ensure smooth program flow and prevent unexpected crashes, developers can use error-handling mechanisms like try-catch blocks. By enclosing Scanner operations in a try block, they can catch and handle potential exceptions that might arise during the input process. This enables programmers to gracefully manage these errors without causing the program to abruptly halt.

Here’s an example of how you might use a try-catch block with a Scanner:

import java.util.Scanner;
import java.util.InputMismatchException;

public class ScannerErrorHandlingExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        try {
            System.out.print("Enter a number: ");
            int num = scanner.nextInt();
            System.out.println("You entered: " + num);
        } catch (InputMismatchException e) {
            System.out.println("Invalid input! Please enter a valid number.");
        }
    }
}

In this example, the try block attempts to read an integer using scanner.nextInt(). If the user enters something that is not an integer, the InputMismatchException will be caught by the catch block, allowing the program to handle the error and continue execution gracefully.

By employing error-handling mechanisms like these, Scanner operations can be safeguarded, ensuring a more robust and fault-tolerant program.

How to Close a Scanner in Java?

Closing a Scanner in Java is essential to release resources and avoid potential memory leaks. The Scanner class provides the close() method, which should be utilized to properly close the scanner and free up system resources. By invoking scanner.close(), you ensure the proper termination of input operations and the release of associated resources, promoting efficient memory management in your Java programs.

Scanner vs Buffered Reader

Below, find a comparison highlighting the key distinctions between Scanner and BufferedReader in Java for input handling and processing.

Things to Consider

Here are some key considerations when using the Java Scanner class:

• Resource Management: Always close the Scanner using the close() method to release system resources after its usage to prevent potential memory leaks.
• Input Validation: Validate user input to handle unexpected or erroneous input using methods like hasNextInt(), hasNextDouble(), or useDelimiter() to set specific delimiters.
• Exception Handling: Utilize try-catch blocks to handle exceptions such as NoSuchElementException or InputMismatchException that might arise from unexpected input scenarios.
• Thread Safety: Scanner instances are not thread-safe. Avoid sharing Scanner instances across multiple threads concurrently to prevent synchronization issues.
• Memory Usage: Consider the memory impact when reading large files or continuous input streams, as the Scanner class might consume significant memory, impacting application performance.
• Input Buffering: When handling large amounts of input, consider using buffered readers for improved efficiency and performance compared to Scanner, especially in file or network input scenarios.
• Unicode and Locale Handling: Take into account the Unicode characters and locale settings when working with Scanner for internationalization and localization requirements.
• Delimiter Configurations: Carefully set delimiters to appropriately segment the input, ensuring accurate tokenization and data extraction.
• User Input Feedback: Provide clear and descriptive prompts for user input to guide and assist users in providing the expected input types.
• Input Sanitization: Implement input sanitization methods to remove unwanted characters or sanitize user inputs for security and data integrity.
• File Handling: For file input, verify file existence and permissions before initiating Scanner operations to prevent unexpected file-related exceptions.
• Scanner Reset: If reusing a Scanner for multiple input sources, ensure to reset it by closing and creating a new instance or using scanner.reset() if working with specific input streams.

FAQs

Conclusion

In conclusion, Java Scanner is used for efficiently handling user input across various sources, whether from the console, files, or strings. With its diverse methods for extracting tokens, converting data types, and customizable delimiters, the Scanner class offers a comprehensive solution for parsing and interpreting input data.

Learn More

Top Picks for Learning Java

Explore the recommended Java books tailored for learners at different levels, from beginners to advanced programmers.

Disclaimer: The products featured or recommended on this site are affiliated. If you purchase these products through the provided links, I may earn a commission at no additional cost to you.

1

13th Edition

Java: The Complete Reference

• All Levels Covered: Designed for novice, intermediate, and professional programmers alike
• Accessible Source Code: Source code for all examples and projects are available for download
• Clear Writing Style: Written in the clear, uncompromising style Herb Schildt is famous for

4.6

Check Price - IndiaCheck Price - Global

2

Head First Java: A Brain-Friendly Guide

• Engaging Learning: It uses a fun approach to teach Java and object-oriented programming.
• Comprehensive Content: Covers Java's basics and advanced topics like lambdas and GUIs.
• Interactive Learning: The book's visuals and engaging style make learning Java more enjoyable.

4.6

Check Price - IndiaCheck Price - Global

3

2nd Edition

Modern Java in Action: Lambdas, streams, functional and reactive programming

• Latest Java Features: Explores modern Java functionalities from version 8 and beyond, like streams, modules, and concurrency.
• Real-world Applications: Demonstrates how to use these new features practically, enhancing understanding and coding skills.
• Developer-Friendly: Tailored for Java developers already familiar with core Java, making it accessible for advancing their expertise.

4.6

Check Price - IndiaCheck Price - Global

4

8th Edition

Java For Dummies

• Java Essentials: Learn fundamental Java programming through easy tutorials and practical tips in the latest edition of the For Dummies series.
• Programming Basics: Gain control over program flow, master classes, objects, and methods, and explore functional programming features.
• Updated Coverage: Covers Java 17, the latest long-term support release, including the new 'switch' statement syntax, making it perfect for beginners or those wanting to brush up their skills.

4.5

Check Price - IndiaCheck Price - Global