Scanner Class in Java (With Examples)

In Java programming, the Scanner class is a powerful tool that allows you to easily receive user input and parse it into various data types. This class is part of the java.util package and was introduced in Java 1.5. With the Scanner class, you can read input from different sources such as the keyboard, files, or even strings.

In this comprehensive guide, we will explore the functionality and usage of the Java Scanner class. We will cover the various constructors, methods, and techniques to effectively use the Scanner class in your Java programs. Whether you are a beginner or an experienced Java developer, this guide will provide you with the knowledge to leverage the full potential of the Scanner class.

Getting Started with the Scanner Class

The Scanner class provides a convenient way to read input from various sources. Let's start by understanding how to initialize the Scanner and read user input.

Initializing the Scanner

To use the Scanner class, the first step is to initialize an instance of the Scanner class. You can create a Scanner object by passing the input source as a parameter to one of the available constructors.

Here's an example of initializing a Scanner object to read input from the keyboard:

Scanner scanner = new Scanner(System.in);

In the above example, we pass System.in as the parameter, which represents the standard input stream, i.e., the keyboard. This allows us to read user input during program execution.

Reading User Input

Once the Scanner object is initialized, we can use its methods to read user input. The most common method is nextLine(), which reads a line of text entered by the user.

Here's an example of using the nextLine() method to read the user's name:

System.out.print("Enter your name: ");
String name = scanner.nextLine();
System.out.println("Hello, " + name + "!");

In the above example, we prompt the user to enter their name using System.out.print(). Then, we use scanner.nextLine() to read the input provided by the user and store it in the name variable. Finally, we print a greeting message using the entered name.

Different Ways to Use the Scanner

The Scanner class provides various methods and constructors that allow you to read input from different sources. Let's explore the different ways you can use the Scanner class in your Java programs.

Parsing Input from the Keyboard

The most common use case for the Scanner class is to parse input entered by the user from the keyboard. By using System.in as the input source, the Scanner can read user input during program execution.

Here's an example of reading an integer input from the user:

System.out.print("Enter a number: ");
int number = scanner.nextInt();
System.out.println("You entered: " + number);

In the above example, we prompt the user to enter a number. Then, we use scanner.nextInt() to read the integer value provided by the user and store it in the number variable. Finally, we print the number.

Reading from Files

The Scanner class also allows you to read input from files. You can pass a File object as a parameter to the Scanner constructor to read data from a file.

Here's an example of reading data from a file using the Scanner:

File file = new File("data.txt");
Scanner fileScanner = new Scanner(file);

while (fileScanner.hasNextLine()) {
    String line = fileScanner.nextLine();
    System.out.println(line);
}

fileScanner.close();

In the above example, we create a File object representing the file "data.txt". Then, we create a Scanner object called fileScanner and pass the File object as a parameter. We use a while loop along with fileScanner.hasNextLine() to iterate through each line of the file. Finally, we close the Scanner once we have finished reading the file.

Parsing Strings

In addition to reading input from the keyboard and files, the Scanner class can also parse input from strings. This is useful when you have a string containing data that you want to extract and process.

Here's an example of parsing a string using the Scanner:

String data = "John,Doe,25";
Scanner stringScanner = new Scanner(data);
stringScanner.useDelimiter(",");

String firstName = stringScanner.next();
String lastName = stringScanner.next();
int age = stringScanner.nextInt();

System.out.println("First Name: " + firstName);
System.out.println("Last Name: " + lastName);
System.out.println("Age: " + age);

stringScanner.close();

In the above example, we create a Scanner object called stringScanner and pass the string data as a parameter. We use stringScanner.useDelimiter(",") to set the delimiter as a comma. Then, we use the next() and nextInt() methods to parse the string and extract the values. Finally, we print the extracted values.

Scanner Constructors

The Scanner class provides several constructors to initialize a Scanner object based on the input source. Let's explore the different constructors and their usage.

Using InputStream

The most common constructor of the Scanner class takes an InputStream object as a parameter. This allows you to read input from various sources, such as the keyboard (System.in).

Here's an example of using the Scanner constructor with an InputStream:

Scanner scanner = new Scanner(System.in);

In the above example, we pass System.in as the parameter, which represents the standard input stream. This allows us to read user input from the keyboard.

Working with Files

The Scanner class also provides constructors to read input from files. You can pass a File object or a file name as a parameter to initialize a Scanner object for file input.

Here's an example of using the Scanner constructor with a File object:

File file = new File("data.txt");
Scanner fileScanner = new Scanner(file);

In the above example, we create a File object representing the file "data.txt". We then pass this File object as a parameter to the Scanner constructor to initialize a Scanner object for file input.

Parsing Strings

The Scanner class also provides constructors to parse input from strings. You can pass a string as a parameter to the Scanner constructor to initialize a Scanner object for string input.

Here's an example of using the Scanner constructor with a string:

String data = "Hello, World!";
Scanner stringScanner = new Scanner(data);

In the above example, we pass the string data as  a parameter to the Scanner constructor. This initializes a Scanner object called stringScanner to parse input from the string.

Scanner Methods

The Scanner class provides various methods to parse different types of input. These methods allow you to read and parse values of different data types, such as integers, doubles, strings, and more. Let's explore some of the commonly used methods of the Scanner class.

Parsing Primitive Types

The Scanner class provides methods to parse input into primitive types such as integers, doubles, booleans, and more. Here are some of the commonly used methods for parsing primitive types:

• nextInt(): Reads the next token as an integer.
• nextDouble(): Reads the next token as a double.
• nextBoolean(): Reads the next token as a boolean.

Here's an example that demonstrates the usage of these methods:

System.out.print("Enter an integer: ");
int number = scanner.nextInt();

System.out.print("Enter a double: ");
double decimal = scanner.nextDouble();

System.out.print("Enter a boolean (true/false): ");
boolean flag = scanner.nextBoolean();

System.out.println("Integer: " + number);
System.out.println("Double: " + decimal);
System.out.println("Boolean: " + flag);

In the above example, we prompt the user to enter an integer, a double, and a boolean value. We use the respective methods (nextInt(), nextDouble(), nextBoolean()) to parse the input into the desired data types. Finally, we print the parsed values.

Parsing Strings

In addition to parsing primitive types, the Scanner class also provides methods to parse strings. These methods allow you to read and parse strings to extract specific portions or tokens.

• next(): Reads the next token as a string.
• nextLine(): Reads the next line of input as a string.

Here's an example that demonstrates the usage of these methods:

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

System.out.print("Enter your address: ");
String address = scanner.nextLine();

System.out.println("Full Name: " + fullName);
System.out.println("Address: " + address);

In the above example, we prompt the user to enter their full name and address. We use the nextLine() method to read the entire line of input as a string. Finally, we print the entered full name and address.

Custom Delimiters

By default, the Scanner class uses whitespace as the delimiter to separate tokens. However, you can specify a custom delimiter to parse input with a different separator.

To set a custom delimiter, you can usse the useDelimiter() method of the Scanner class. You can pass a regular expression pattern as the delimiter.

Here's an example of using a custom delimiter to parse a comma-separated string:

String data = "John,Doe,25";
Scanner stringScanner = new Scanner(data);
stringScanner.useDelimiter(",");

String firstName = stringScanner.next();
String lastName = stringScanner.next();
int age = stringScanner.nextInt();

System.out.println("First Name: " + firstName);
System.out.println("Last Name: " + lastName);
System.out.println("Age: " + age);

stringScanner.close();

In the above example, we set the delimiter to a comma using stringScanner.useDelimiter(","). This allows us to parse the comma-separated string and extract the first name, last name, and age values.

Checking Input

The Scanner class provides methods to check the availability and type of the next token without actually consuming it. These methods can be helpful to validate user input before parsing.

• hasNext(): Returns true if there is another token available for reading.
• hasNextInt(): Returns true if the next token can be parsed as an integer.
• hasNextDouble(): Returns true if the next token can be parsed as a double.

Here's an example that demonstrates the usage of these methods:

System.out.print("Enter a number: ");

if (scanner.hasNextInt()) {
    int number = scanner.nextInt();
    System.out.println("You entered an integer: " + number);
} else if (scanner.hasNextDouble()) {
    double decimal = scanner.nextDouble();
    System.out.println("You entered a double: " + decimal);
} else {
    String input = scanner.next();
    System.out.println("Invalid input: " + input);
}

In the above example, we prompt the user to enter a number. We use scanner.hasNextInt() and scanner.hasNextDouble() to check if the next token can be parsed as an integer or a double, respectively. Depending on the input type, we perform the appropriate action and provide feedback to the user.

Handling Exceptions with the Scanner

When working with the Scanner class, there are certain exceptions that can occur if the input provided by the user does not match the expected type. It is important to handle these exceptions to prevent program crashes and provide a graceful user experience.

InputMismatchException

The InputMismatchException is thrown when the token retrieved by the Scanner cannot be parsed as the expected data type. For example, if the user enters a non-numeric value when an integer is expected, an InputMismatchException will be thrown.

To handle this exception, you can use a try-catch block. Here's an example:

System.out.print("Enter a number: ");

try {
    int number = scanner.nextInt();
    System.out.println("You entered: " + number);
} catch (InputMismatchException e) {
    System.out.println("Invalid input. Please enter a valid number.");
}

In the above example, we use a try-catch block to catch the InputMismatchException. If an exception occurs, we display an error message to the user.

NoSuchElementException

The NoSuchElementException is thrown when there are no more tokens available to be read by the Scanner. This can happen if you call a nextXXX() method when there are no more tokens left to parse.

To handle this exception, you can use a try-catch block. Here's an example:

System.out.print("Enter your name: ");

try {
    String name = scanner.next();
    System.out.println("Hello, " + name + "!");
} catch (NoSuchElementException e) {
    System.out.println("No input found. Please enter your name.");
}

In the above example, we catch the NoSuchElementException and display an error message if no input is found.

Closing the Scanner

When you are finished using the Scanner class, it is important to close the Scanner object to release system resources. This can be done using the close() method.

Here's an example of closing the Scanner:

scanner.close();

By closing the Scanner, you ensure that any underlying resources, such as file handles or network connections, are properly released. It is good practice to close the Scanner when you no longer need it.

Best Practices for Using the Scanner

To effectively use the Scanner class in your Java programs, it is important to follow some  best practices. These practices will help you avoid common pitfalls and ensure that your code is efficient and robust.

Avoiding Resource Leaks

When using the Scanner class, it is crucial to close the Scanner object after you have finished using it. Failing to do so can result in resource leaks, such as unclosed file handles or network connections.

To ensure proper resource management, you can use the try-with-resources statement introduced in Java 7. This statement automatically closes the Scanner object at the end of the block, even if an exception occurs.

Here's an example of using try-with-resources to automatically close the Scanner:

try (Scanner scanner = new Scanner(System.in)) {
    // Use the Scanner here
} // The Scanner is automatically closed at the end of the block

By using try-with-resources, you eliminate the need for manual resource management and ensure that the Scanner is always closed properly.

Handling Invalid Input

When working with user input, it is important to handle cases where the input does not match the expected format or type. For example, if you expect an integer but the user enters a non-numeric value, it can result in an exception.

To handle invalid input, you can use a combination of hasNextXXX() methods and conditional statements to validate the input before parsing it. This allows you to provide appropriate error messages and prompt the user to enter valid input.

Here's an example of handling invalid input:

System.out.print("Enter your age: ");

if (scanner.hasNextInt()) {
    int age = scanner.nextInt();
    System.out.println("Age: " + age);
} else {
    System.out.println("Invalid input. Please enter a valid age.");
    // Consume the invalid input to avoid an infinite loop
    scanner.next();
}

In the above example, we use scanner.hasNextInt() to check if the next token can be parsed as an integer. If it can, we proceed with parsing the input and processing it. Otherwise, we display an error message and consume the invalid input using scanner.next().

Using Try-With-Resources

As mentioned earlier, it is good practice to use try-with-resources to automatically close the Scanner object and release system resources. This ensures that the Scanner is properly closed, even if an exception occurs.

Here's an example of using try-with-resources with the Scanner:

try (Scanner scanner = new Scanner(System.in)) {
    // Use the Scanner here
} // The Scanner is automatically closed at the end of the block

By using try-with-resources, you simplify your code and avoid potential resource leaks.

Performance Considerations

The Scanner class is convenient for parsing input, but it may not be the most performant solution for certain use cases. The Scanner class uses regular expressions to parse input, which can be slower compared to other parsing techniques.

If you require high-performance parsing, consider using alternative parsing approaches, such as using BufferedReader for reading lines from files or manually parsing strings using StringTokenizer or regular expressions.

It is important to strike a balance between convenience and performance when choosing the appropriate parsing technique for your specific use case.

Common Use Cases for the Scanner

The Scanner class can be used in various scenarios to parse input and extract relevant information. Let's explore some common use cases for the Scanner class.

Calculating the Sum of Numbers

One common use case for the Scanner class is to calculate the sum of a series of numbers entered by the user. By repeatedly reading numbers using the nextInt() method and summing them, you can calculate the total.

Here's an example:

System.out.print("Enter a series of numbers (separated by spaces): ");

int sum = 0;
while (scanner.hasNextInt()) {
    int number = scanner.nextInt();
    sum += number;
}

System.out.println("Sum: " + sum);

In the above example, we prompt the user to enter a series of numbers separated by spaces. We use a while loop and scanner.hasNextInt() to continuously read numbers until the input is exhausted. The numbers are summed in the sum variable, and the final result is printed. 

Reading CSV Files

The Scanner class can be used to read and parse data from CSV (Comma-Separated Values) files. By setting the delimiter to a comma and parsing each line using the next() or nextLine() methods, you can extract individual values from each line.

Here's an example:

File file = new File("data.csv");
Scanner fileScanner = new Scanner(file);
fileScanner.useDelimiter(",");

while (fileScanner.hasNextLine()) {
    String line = fileScanner.nextLine();
    Scanner lineScanner = new Scanner(line);

    while (lineScanner.hasNext()) {
        String value = lineScanner.next();
        System.out.println(value);
    }

    lineScanner.close();
}

fileScanner.close();

In the above example, we read data from a CSV file named "data.csv". We use fileScanner.nextLine() to read each line of the file and lineScanner.next() to extract individual values from each line. Finally, we close both the lineScanner and fileScanner to release system resources.

Validating User Input

The Scanner class can also be used to validate user input by checking if it matches a specific pattern or condition. By combining hasNextXXX() methods and conditional statements, you can enforce data validation rules.

Here's an example:

System.out.print("Enter a valid email address: ");
String email = scanner.next();

if (email.matches("[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z0-9]+")) {
    System.out.println("Valid email address: " + email);
} else {
    System.out.println("Invalid email address. Please enter a valid email address.");
}

In the above example, we prompt the user to enter an email address. We use the matches() method of the String class and a regular expression pattern to validate if the entered email address matches the expected format. Depending on the result, we display a message indicating whether the email address is valid or invalid.

Conclusion

The Scanner class in Java is a powerful tool that allows you to easily receive user input and parse it into various data types. It provides several constructors and methods to handle different input sources and data formats. By following the best practices and understanding the various use cases, you can effectively leverage the Scanner class in your Java programs.

In this comprehensive guide, we have covered the basics of the Scanner class, its usage, and the most commonly used methods. We have also explored best practices for handling exceptions, managing resources, and optimizing performance. By mastering the Scanner class, you can enhance user interaction and create more robust and dynamic Java applications.

Remember to always handle exceptions, close the Scanner properly, and validate user input to ensure the reliability and stability of your code. With the knowledge and techniques gained from this guide, you are well-equipped to harness the power of the Scanner class in your Java programming journey. Happy coding!