Terminating Scanner When Input Is Complete in Java

1. Introduction

When working with Java programs that read input from the console, we use the Scanner class. It’s simple, powerful, and flexible enough to handle various types of input, including integers, doubles, and strings. However, one of the most common challenges developers face when working with a Scanner object is figuring out how to stop reading input once the task is complete.

Let’s consider a situation where we want to read multiple lines of input, process them, and then terminate the program gracefully. At first glance, it might seem that pressing the Return key a few times should signal to the program that input has ended. Unfortunately, the program continues to wait for more input, as it doesn’t inherently know when we’ve finished typing.

In this tutorial, we’ll explore how to terminate a Java Scanner after input is complete. First, we’ll discuss different strategies for terminating a scanner, and look at code examples that demonstrate correct approaches. Further, we’ll examine why certain basic attempts might fail. Lastly, we’ll conclude with best practices for writing clean, input-handling code in Java.

2. Terminating the Scanner Class

A Scanner connected to System.in continuously waits for input. From the coding perspective, as long as the user hasn’t explicitly told it to stop, it assumes more input may follow. Pressing the Return key simply indicates the end of one line, not the end of the entire input stream.

For instance, let’s consider a simple case of Scanner termination:

import java.util.Scanner;
public class SampleScanner {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        try {
            while (scan.hasNextLine()) {
                String line = scan.nextLine().toLowerCase();
                System.out.println(line);
            }
        } finally {
           scan.close();
        }
    }
}

At first glance, the logic seems simple. The loop keeps reading lines and prints them until no more lines are available. However, unless the program receives an explicit end-of-input signal, hasNextLine() keeps returning true. That’s why the loop doesn’t terminate automatically when the user simply presses Return several times.

3. Scanner Termination Considerations

Notably, care should be taken when using Scanner in terms of its termination.

3.1. Closing the Scanner Class

When working with Scanner, it’s important to close the resource to avoid memory leaks. However, if the Scanner is reading from System.in, closing it also closes the underlying input stream, which cannot be reopened.

This may result in further errors.

3.2. Graceful Termination vs. Forced Exit

Some examples show the use of System.exit(0) to terminate immediately. While this works, it’s a blunt tool. A cleaner approach is to break out of the loop, enabling the program to finish naturally.

This is especially important when multithreading.

4. Wrongly Using the == Operator to Check the Input

If we try to compare input directly using == or by checking whether the input equals an empty string to terminate the Scanner input, it mostly won’t work. One exception is targeting empty strings specifically.

For example, let’s consider the scan.nextLine comparison in SampleScannerScan.java:

import java.util.Scanner;
public class SampleScannerScan {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        try {
            while (scan.hasNextLine()) {
                String line = scan.nextLine();
                if (line == null) {
                    System.out.println("Exiting program (null check)...");
                    System.exit(0);
                }
                System.out.println("Input was: " + line);
            }
        } finally {
            scan.close();
        }
    }
}

The == operator checks whether two references point to the same object, not whether the contents of two strings are equal. Therefore, even if two strings contain the same characters, == may return false. To properly compare strings, we need to use .equals() or .isEmpty().

5. Using End-of-File (EOF) Marker

The most direct approach for actually closing Scanner is to let the user indicate end-of-input using the operating system EOF marker. On Unix-like systems, this is a control character indicated via CTRL+D, while Windows uses CTRL+Z. When the EOF marker is sent, hasNextLine() returns false, and the loop ends naturally.

Let’s look at the sample code in EOFExample.java that demonstrates the use of EOF:

import java.util.Scanner;
public class EOFExample {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        try {
            System.out.println("Enter text (press CTRL+D on Unix/Mac or CTRL+Z on Windows to end):");
            while (scan.hasNextLine()) {
                String line = scan.nextLine();
                System.out.println("You entered: " + line);
            }
            System.out.println("End of input detected. Program terminated.");
        } finally {
            scan.close();
        }
    }
}

This approach works without modifying the code, but it relies on the user knowing how to send the EOF signal. However, it may not always be the most user-friendly option.

5. Using a Sentinel Value

Another common method for terminating Scanner gracefully is to define a special keyword that indicates the user is finished. This sentinel value could be something simple like exit, quit, or even a symbol such as ##. The program can check each line, and when it matches the sentinel, it terminates gracefully.

Let’s modify the SampleScannerSentinel.java to check the Scanner termination:

import java.util.Scanner;
public class SampleScannerSentinel {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        try {
            while (scan.hasNextLine()) {
                String line = scan.nextLine().toLowerCase();
                if (line.equals("exit")) {
                    System.out.println("Exiting program...");
                    break;
                }
                System.out.println(line);
            }
        } finally {
            scan.close();
        }
    }
}

In this version, typing exit immediately ends the loop. This approach is easier, as the user knows exactly how to signal completion.

6. Using a do-while Loop

Another choice for completing Scanner is to use a do-while loop. This structure ensures that at least one line is read before the termination condition is checked. Let’s look at the code from the SampleScanner.java file, but with a do-while loop (DoWhileScanner.java):

import java.util.Scanner;
public class DoWhileScanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String input;
        do {
            input = sc.nextLine();
            System.out.println(input);
        } while (!input.equals("exit"));
        sc.close();
    }
}

In this example, the program keeps looping until the sentinel word exit is typed. It’s clean, straightforward, and ensures the immediate processing of user input.

7. Conclusion

In this article, we covered how to terminate Scanner when input is complete in Java. The two most effective approaches either employ the system EOF marker or define a sentinel value like exit. While the EOF marker is efficient, the sentinel method often provides a clearer experience for users. Furthermore, we also learned why naive solutions like checking for null or using == fail.

The source code is available over on GitHub.