How to Close a Scanner in Java

1. Close a Scanner in Java Using close()
2. Conclusion

In this tutorial, we will learn how to close a scanner in Java and when we should use it.

The Scanner class has a method close() that is especially available to close the opened scanner. It is a good practice to close a scanner explicitly.

Below are the examples that show how and when we can use the Scanner.close() method.

Close a Scanner in Java Using close()

The Scanner.close() method in Java is used to close the Scanner object, releasing any system resources associated with it. Closing a Scanner is essential for proper resource management, especially when the scanner is reading from external sources like files or streams.

This method should be called when the scanner is no longer needed to prevent potential resource leaks and ensure efficient memory usage. Additionally, closing the scanner prevents further operations on it and signals the end of its usage.

Case 1: Handling Standard Input From the User

In Java, when using the Scanner class to handle standard input from the user, it’s essential to close the scanner using the close() method to release system resources. This ensures proper cleanup and prevents resource leaks.

Always include scanner.close() after reading user input to maintain code efficiency and avoid potential issues with unclosed resources.

Let’s delve into a complete working code example demonstrating how to use the close() method with a Scanner. Additionally, we’ll introduce a scenario where an IllegalStateException may occur.

import java.util.Scanner;

public class ScannerClosingExample {
  public static void main(String[] args) {
    // Creating a Scanner for standard input
    Scanner userInputScanner = new Scanner(System.in);

    // Prompting the user for input
    System.out.print("Enter Pet's Name: ");

    try {
      // Reading user input
      String userInput = userInputScanner.nextLine();

      // Printing the input
      System.out.println("Pet's Name: " + userInput);

      // Attempting to close the Scanner
      userInputScanner.close();

      // Simulating an illegal state by using the closed Scanner
      userInputScanner.nextLine(); // This line will throw an IllegalStateException
    } catch (IllegalStateException e) {
      System.err.println("IllegalStateException: Scanner is closed.");
    }
  }
}

In the presented code example, the process begins with the creation of a Scanner named userInputScanner designed to interact with standard input, specifically associated with System.in.

Subsequently, a user prompt is displayed, inviting input from the user. The program then employs the nextLine() method to capture the text entered by the user.

Following this, the entered input is printed to the console, demonstrating the effective utilization of the Scanner for handling standard input.

As a crucial aspect of resource management, the close() method is invoked on the Scanner to release associated resources after their intended use. To highlight the significance of this step, an intentional attempt to use nextLine() after closing the Scanner is made, resulting in the triggering of an IllegalStateException.

The code includes a mechanism to catch and handle this exception, presenting an informative error message that underscores the importance of closing the scanner appropriately.

Output:

Enter Pet's Name: Pillow
Pet's Name: Pillow
IllegalStateException: Scanner is closed.

When the user runs this program, they will be prompted to enter something. After entering the text, the program will print the input. However, when it attempts to use nextLine() on the closed Scanner, an IllegalStateException will be thrown. The catch block will handle this exception, indicating that the scanner is closed.

Case 2: After Reading the Contents of a File

In Java, when reading contents from a file using the Scanner class, it’s crucial to close the scanner with the close() method after finishing the file operations. This ensures proper resource management, releases system resources and prevents potential issues related to unclosed file connections.

Always include scanner.close() to maintain code reliability and efficiency when handling file input.

Failing to close a Scanner instance after reading a file could lead to resource leaks and unexpected behavior.

Here’s a simple example of using the close() method with a Scanner after reading contents from a file :

example.txt:

Hello! My name is Pillow and I am a Chihuahua!

Example:

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

public class FileScannerClosingExample {
  public static void main(String[] args) {
    try {
      // Creating a Scanner for reading from a file
      File file = new File("example.txt");
      Scanner fileScanner = new Scanner(file);

      // Reading and printing file contents
      while (fileScanner.hasNextLine()) {
        System.out.println(fileScanner.nextLine());
      }

      // Attempting to read more from the closed Scanner
      fileScanner.nextLine(); // This line will throw an IllegalStateException

      // Closing the Scanner to release file resources
      fileScanner.close();
    } catch (FileNotFoundException e) {
      System.err.println("File not found: " + e.getMessage());
    } catch (IllegalStateException e) {
      System.err.println("IllegalStateException: Scanner is closed.");
    }
  }
}

In the code example, we start by creating a Scanner named fileScanner associated with a file named example.txt.

Subsequently, we employ a while loop to iterate through the lines of the file, printing each line to the console. This step illustrates the primary purpose of using a Scanner for reading file contents.

To emphasize the importance of closing the scanner after its intended use, we intentionally attempt to read more from the closed Scanner by using nextLine(). As expected, this results in an IllegalStateException, underscoring the necessity of proper resource management.

Finally, we invoke the close() method on the Scanner to release the file-related resources.

Exception handling is also incorporated, where a FileNotFoundException is caught if the specified file is not found, and an IllegalStateException is caught to manage the attempt to read from a closed scanner.

Output:

Hello! My name is Pillow and I am a Chihuahua!
Exception in thread "main" java.util.NoSuchElementException: No line found
        at java.base/java.util.Scanner.nextLine(Scanner.java:1651)
        at Scanz.main(Scanz.java:19)

When the user runs this program with an existing file, example.txt, it will successfully read and print the file’s contents line by line. However, attempting to read more from the closed Scanner will trigger an IllegalStateException.

Both exceptions are caught and handled, providing informative error messages.

Conclusion

In conclusion, the close() method is a fundamental practice for ensuring proper resource management when utilizing the Scanner class in Java. This method plays a pivotal role in preventing potential issues, such as the IllegalStateException, by releasing associated resources and signaling the end of the scanner’s usage.

By adhering to this best practice, developers enhance the overall stability and reliability of their Java applications.

Closing a Scanner after reading the contents of a file is a critical practice in Java programming, contributing significantly to effective resource management. This practice ensures the proper release of file-related resources, mitigating potential issues like the IllegalStateException that may arise when attempting to use a closed scanner.

By incorporating this approach, developers actively contribute to the reliability and efficiency of their Java applications, particularly when handling file input. The close() method, when appropriately employed, safeguards against resource leaks and enhances the overall robustness of Java programs.