Do You Need to Import Scanner in Java? A Practical Guide

Learn when and how to import java.util.Scanner in Java, with clear explanations, code examples, and best practices for console input, file IO, and performance.

Scanner Check Team

March 2, 2026·5 min read

Scanner Scanner Review Data Scan

Quick AnswerDefinition

To use Scanner in Java, you typically import java.util.Scanner at the top of your source file. The import makes the class available by its simple name, improving readability. If you prefer, you can reference the fully-qualified name (java.util.Scanner) without an import, but this is uncommon in real-world code. Most projects import Scanner and then instantiate it as new Scanner(System.in).

Do you need to import Scanner in Java? Do you need to import scanner in java

If you're wondering do you need to import scanner in java, the answer is usually yes; you import java.util.Scanner at the top of your file to access the class by its short name. The import maps the simple name to its fully-qualified class, which improves readability and makes the code look cleaner. If you omit the import, you can still reference the class using its fully-qualified name (java.util.Scanner), but this approach is verbose and rarely used in production. In practice, add the import and proceed with a straightforward usage like new Scanner(System.in) for console input.

Java

// Example with import
package com.example;

import java.util.Scanner;

public class InputDemo {
    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int value = scanner.nextInt();
            System.out.println("Value: " + value);
        }
    }
}

Java

// Example without import (fully-qualified name)
package com.example;

public class ImportCompat {
    public static void main(String[] args) {
        java.util.Scanner scanner = new java.util.Scanner(System.in);
        String line = scanner.nextLine();
        System.out.println("Line: " + line);
        scanner.close();
    }
}

In summary, importing java.util.Scanner is the standard practice; you can use the full name if you want to minimize imports, but it’s less readable. For console input, bind the Scanner to System.in and close it when finished; if you want to allow robust resource handling, consider try-with-resources.

Import basics: import vs fully-qualified name

Understanding imports is foundational in Java. When you write import java.util.Scanner; you map the simple class name (Scanner) to its fully-qualified name (java.util.Scanner). This lets you write clean code without repeating the package for every reference. Without the import, you must prepend java.util.Scanner to every reference, which can clutter the code, especially in larger files. Both approaches are valid; the choice often comes down to readability and project conventions.

Java

import java.util.Scanner;

public class Demo {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("Enter a line:");
        String line = s.nextLine();
        System.out.println("You entered: " + line);
        s.close();
    }
}

Java

public class DemoNoImport {
    public static void main(String[] args) {
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("Enter a line:");
        String line = s.nextLine();
        System.out.println("You entered: " + line);
        s.close();
    }
}

Key takeaways:

Imports reduce verbosity and improve readability.
Fully-qualified names avoid imports but clutter code.
Consistency in your team’s style helps maintainability.

Reading input safely with Scanner

Scanner is convenient for reading tokens from various sources (System.in, files, strings). The main caveat is resource management and a few parsing quirks (like the interaction between nextInt and nextLine). The examples below demonstrate safe patterns and common pitfalls. Start with a simple console read, then expand to files or strings as needed.

Java

import java.util.Scanner;

public class SafeInput {
    public static void main(String[] args) {
        try (Scanner in = new Scanner(System.in)) {
            System.out.print("Enter an integer: ");
            if (in.hasNextInt()) {
                int n = in.nextInt();
                in.nextLine(); // consume the remaining newline
                System.out.print("Enter a line after the number: ");
                String rest = in.nextLine();
                System.out.println("Number: " + n + ", Rest: " + rest);
            } else {
                System.out.println("Input was not an integer.");
            }
        }
    }
}

Java

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

public class FileRead {
    public static void main(String[] args) throws FileNotFoundException {
        File f = new File("data.txt");
        try (Scanner fileScanner = new Scanner(f)) {
            while (fileScanner.hasNext()) {
                System.out.print(fileScanner.next() + " ");
            }
        }
    }
}

Java

// Token parsing from a string
public class TokenFromString {
    public static void main(String[] args) {
        String input = "alpha 123 beta 456";
        Scanner s = new Scanner(input);
        while (s.hasNext()) {
            System.out.println(s.next());
        }
        s.close();
    }
}

Notes:

Using try-with-resources ensures the Scanner is closed when the source is exhausted or an exception occurs.
When reading from System.in, closing the scanner may also close System.in for the rest of the application; plan your lifecycle accordingly.
Validate inputs with hasNextX checks before using nextX methods to avoid exceptions.

Performance considerations and alternatives

Scanner offers simplicity, but it carries overhead from tokenizing input. For large-scale input or performance-sensitive applications, alternative approaches like BufferedReader with StringTokenizer or manual parsing can be significantly faster. The trade-off is often between developer productivity and runtime efficiency. The following examples compare a typical Scanner-based approach with a faster alternative and illustrate how to switch when needed.

Java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class BRTokenizer {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();
        StringTokenizer st = new StringTokenizer(line);
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());
        System.out.println("Sum="+(a+b));
    }
}

Java

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class BRReadLine {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = br.readLine();
        String[] parts = line.trim().split("\\s+");
        int a = Integer.parseInt(parts[0]);
        int b = Integer.parseInt(parts[1]);
        System.out.println(a + b);
    }
}

Guidance:

Use Scanner for simple, quick prototypes or small inputs.
Switch to BufferedReader-based parsing when input size grows or latency matters.
Profile with representative data to determine the bottleneck before optimizing prematurely.

Practical usage patterns and edge cases

Beyond console input, Scanner shines when you need flexible parsing from files or embedded strings. It can be used to read primitive types and strings with a forgiving API, which reduces boilerplate in small tooling or scripts. The examples below illustrate common real-world scenarios and the edge cases you might encounter.

Java

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

public class ScanNumbersFromFile {
    public static void main(String[] args) throws FileNotFoundException {
        File f = new File("numbers.txt");
        try (Scanner sc = new Scanner(f)) {
            while (sc.hasNextInt()) {
                System.out.println("Value: " + sc.nextInt());
            }
        }
    }
}

Java

import java.util.Scanner;

public class ScanFromString {
    public static void main(String[] args) {
        String data = "one 2 two 3";
        Scanner s = new Scanner(data);
        while (s.hasNext()) {
            System.out.println("Token: " + s.next());
        }
        s.close();
    }
}

Edge cases to watch:

Mixed input types require careful nextInt/nextDouble calls and appropriate hasNext checks.
When parsing lines with different token types, consume newlines properly to avoid mixing tokens.
When reading from a resource like a jar-internal file, use getResourceAsStream and wrap it with a Scanner.
Always ensure there is a clear lifecycle for the Scanner, especially with System.in, to avoid closing standard input prematurely.

Best practices and common mistakes

To close the guide, here are distilled practices and pitfalls to avoid when using Scanner in Java. Following these helps maintain robust, readable code and predictable behavior across environments.

Pro tip: Always prefer try-with-resources when the Scanner wraps a Closeable source. This guarantees the resource is released even if parsing fails.
Warning: Do not close System.in prematurely. Closing a Scanner bound to System.in may close the standard input stream for the rest of the program.
Note: For large-scale input, benchmark Scanner against BufferedReader with StringTokenizer or custom parsers to choose the best tool for your workload.
Pro tip: Validate inputs with hasNextX guards before consuming tokens to avoid InputMismatchException and to provide clearer error messages.
Warning: Be mindful of locale when parsing numbers with Scanner; locales affect decimal separators and number formats, which can lead to subtle bugs if your data comes from varied sources.
Note: When reading from files, propagate FileNotFoundException or handle it gracefully; consider resource cleanup and meaningful error logs for maintainability.

Steps

Estimated time: 20-40 minutes

1
Set up your project
Create a simple Java class and package structure; configure your build tool if you use Maven or Gradle; ensure the IDE recognizes the project. Start with a small main class for input tests.
Tip: Use a minimal, isolated example to avoid IDE quirks.
2
Add the import
Add import java.util.Scanner; at the top of the file or rely on a fully-qualified name if you prefer to avoid imports.
Tip: Prefer the import for readability and maintainability.
3
Write code to read input
Create a Scanner bound to System.in (or another InputStream) and read tokens with nextInt, nextLine, etc.
Tip: Validate inputs with hasNextX checks before consuming.
4
Close resources
Close the Scanner when done, preferably with try-with-resources to avoid leaks and ensure cleanup.
Tip: Remember: closing the wrong source (e.g., System.in) can affect later input.

Pro Tip: Prefer try-with-resources to automatically close the Scanner when reading from a resource.

Warning: Be careful: closing a Scanner that wraps System.in may close the standard input stream for the rest of the program.

Note: Scanner performance can be slower than BufferedReader for large inputs; consider alternatives for high-volume parsing.

Prerequisites

Required

Java JDK 11+ installed↗
Required
A Java IDE or text editor↗
Required
Basic knowledge of Java syntax (imports, classes, methods)
Required

Optional

Optional: Build tool (Maven or Gradle)↗
Optional
Understanding of System.in and basic file IO
Optional

Keyboard Shortcuts

Action	Shortcut
CopyCopy code or text as needed.	`Ctrl`+`C`
PastePaste into your editor or terminal.	`Ctrl`+`V`
Comment lineToggle line comments in most IDEs.	`Ctrl`+`/`
Format codeFormat source to conform to style guidelines.	`Ctrl`+`Alt`+`L`

Common Questions

Do I always need to import java.util.Scanner?

Not always. If you prefer, you can use the fully-qualified name java.util.Scanner without an import, but importing is the standard practice for readability and maintainability.

Can Scanner read from files or strings?

Yes. You can instantiate Scanner with a File or with a String to parse tokens.

Is Scanner thread-safe?

Scanner is not inherently thread-safe. If used by multiple threads, synchronize access or use separate instances.

What are common alternatives to Scanner?

BufferedReader with StringTokenizer can be faster; use Scanner for simplicity and small inputs.

How do I safely close a Scanner?

Use try-with-resources to ensure the Scanner is closed properly.

Key Takeaways

Import java.util.Scanner for readability and consistency.
Use try-with-resources to manage Scanner lifecycle.
Validate input with hasNextX before consuming tokens.
Reference fully-qualified name only when avoiding imports.
Scanner is convenient for small inputs but not optimal for large data handling.

← More in Document Scanning Basics

Do you need to import Scanner in Java? Do you need to import scanner in java

Import basics: import vs fully-qualified name

Reading input safely with Scanner

Performance considerations and alternatives

Practical usage patterns and edge cases

Best practices and common mistakes

Steps

Set up your project

Add the import

Write code to read input

Close resources

Prerequisites

Keyboard Shortcuts

Common Questions

Key Takeaways

Related Articles