Taking Input with Scanner

What Is It?

What Is User Input in Java?

In most real programs, data does not come from hardcoded values inside the source code. It comes from outside: the user types something into the console, a file is read from disk, or data arrives over the network. User input refers to data that a user provides to a running program, typically through the keyboard.

Java provides several ways to read user input. The most common approach for console-based programs is the Scanner class, which lives in the java.util package. Scanner can parse primitive types and strings from an input stream, most commonly System.in (the standard keyboard input).

The Basic Flow

Reading input in Java involves three steps:

1. Import the Scanner class: import java.util.Scanner;
2. Create a Scanner object: Scanner sc = new Scanner(System.in);
3. Read data using methods like nextInt(), nextDouble(), nextLine(), etc.

After you are done reading input, you should close the Scanner to release resources: sc.close();

Why Does It Matter?

Why Is Understanding Input Important?

1. Programs Must Interact with Users

A program that only prints hardcoded output is useless in practice. Whether you are building a calculator, a grading system, or a login module, your program needs to accept data from the user at runtime. Understanding how to read input correctly is foundational to writing any interactive Java program.

2. Input Handling Is a Common Source of Bugs

One of the most frequent bugs that Java beginners encounter is the nextLine() after nextInt() problem, where Scanner appears to skip input. Understanding how Scanner works internally (its token-based parsing and the leftover newline character) is essential for writing bug-free input code. This is also a common interview question.

3. Type Safety and Validation

Java is a statically typed language. When you read input, you need to read it as the correct type. Using nextInt() when the user types a string causes an InputMismatchException. Knowing how to handle different input types and validate them is critical for robust programs.

4. Placement and Interview Relevance

In coding rounds for placements, you will almost always read input from the console. Many students lose time or get wrong answers because they do not handle input correctly. Mastering Scanner (and knowing the BufferedReader alternative for performance-critical scenarios) gives you an edge.

Detailed Explanation

Detailed Explanation

1. Importing and Creating a Scanner

The Scanner class is in the java.util package. You must import it before using it. Then, create a Scanner object by passing System.in (which represents the keyboard) as the input source.

import java.util.Scanner;

public class InputDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        // Now use sc to read input
        sc.close();
    }
}

System.in is an InputStream that reads bytes from the keyboard. Scanner wraps it and provides convenient methods to parse those bytes into Java types like int, double, and String.

2. Reading Different Data Types

Scanner provides specific methods for each data type:

3. next() vs nextLine()

This distinction is critical and is a source of many bugs:

• next() reads a single token. A token is a sequence of characters separated by whitespace (spaces, tabs, newlines). If the user types "Amit Kumar", next() returns only "Amit". The " Kumar" part remains in the input buffer.
• nextLine() reads the entire line up to the newline character. If the user types "Amit Kumar" and presses Enter, nextLine() returns "Amit Kumar". It consumes the newline character but does not include it in the returned string.

4. The nextLine() After nextInt() Bug

This is the single most common Scanner bug in Java. When you call nextInt() (or nextDouble(), nextFloat(), etc.), Scanner reads the number but does not consume the newline character that the user pressed after typing the number. That leftover newline sits in the input buffer.

When you then call nextLine(), it sees that leftover newline and immediately returns an empty string, without waiting for the user to type anything. It appears as if the program "skipped" the input.

Scanner sc = new Scanner(System.in);
System.out.print("Enter age: ");
int age = sc.nextInt();           // User types: 21\n
System.out.print("Enter name: ");
String name = sc.nextLine();      // Reads the leftover \n, returns ""
System.out.println("Name: " + name); // Prints: Name:

The Fix: Consume the Leftover Newline

Add an extra sc.nextLine() call immediately after nextInt() to consume the leftover newline before reading the actual string input:

int age = sc.nextInt();
sc.nextLine();  // Consume the leftover newline
String name = sc.nextLine();  // Now this works correctly

Alternatively, you can read everything as strings using nextLine() and then parse them manually:

int age = Integer.parseInt(sc.nextLine());
String name = sc.nextLine();  // No leftover newline problem

5. Checking Input Before Reading: hasNext Methods

Scanner provides hasNextInt(), hasNextDouble(), hasNextLine(), etc. These methods return true if the next token can be read as the specified type, without actually consuming it. This is useful for input validation:

System.out.print("Enter a number: ");
if (sc.hasNextInt()) {
    int num = sc.nextInt();
    System.out.println("You entered: " + num);
} else {
    System.out.println("That is not a valid integer.");
    sc.next(); // Consume the invalid token
}

6. Closing the Scanner

When you are done reading input, you should close the Scanner by calling sc.close(). This releases the underlying input stream resource. However, be aware that closing a Scanner that wraps System.in also closes System.in itself, which means you cannot create another Scanner for System.in later in the same program.

For simple programs, not closing Scanner results in a compiler warning but usually no practical harm. For larger programs or when reading from files, always close the Scanner.

7. try-with-resources for Scanner

Java 7 introduced the try-with-resources statement, which automatically closes resources when the block exits. Since Scanner implements the AutoCloseable interface, you can use it with try-with-resources:

try (Scanner sc = new Scanner(System.in)) {
    System.out.print("Enter a number: ");
    int num = sc.nextInt();
    System.out.println("You entered: " + num);
} // Scanner is automatically closed here

This is considered best practice because it guarantees the Scanner is closed even if an exception occurs.

8. BufferedReader: The Performance Alternative

For competitive programming or situations where you need to read large amounts of input quickly, BufferedReader is faster than Scanner because it does not parse tokens. It reads raw text and you parse it yourself.

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

public class FastInput {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        System.out.print("Enter your name: ");
        String name = br.readLine();
        System.out.print("Enter your age: ");
        int age = Integer.parseInt(br.readLine().trim());
        System.out.println(name + " is " + age + " years old.");
        br.close();
    }
}

BufferedReader reads entire lines as strings. You must parse numbers manually using Integer.parseInt(), Double.parseDouble(), etc. For reading multiple values on one line, combine BufferedReader with StringTokenizer or String.split().

Code Examples

import java.util.Scanner;

public class BasicInput {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter your age: ");
        int age = sc.nextInt();

        sc.nextLine(); // Consume leftover newline

        System.out.print("Enter your name: ");
        String name = sc.nextLine();

        System.out.println(name + " is " + age + " years old.");
        sc.close();
    }
}

import java.util.Scanner;

public class MultiTypeInput {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter an integer: ");
        int i = sc.nextInt();

        System.out.print("Enter a double: ");
        double d = sc.nextDouble();

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

        System.out.println("int: " + i);
        System.out.println("double: " + d);
        System.out.println("boolean: " + b);

        sc.close();
    }
}

import java.util.Scanner;

public class NextVsNextLine {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter a sentence: ");
        String word = sc.next();       // Reads only the first word
        String rest = sc.nextLine();   // Reads the rest of the line

        System.out.println("next() returned: \"" + word + "\"");
        System.out.println("nextLine() returned: \"" + rest + "\"");

        sc.close();
    }
}

import java.util.Scanner;

public class NextLineBug {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // --- THE BUG ---
        System.out.println("=== Without fix ===");
        System.out.print("Enter roll number: ");
        int roll = sc.nextInt();
        // sc.nextLine() is NOT called here
        System.out.print("Enter name: ");
        String buggyName = sc.nextLine();  // Reads leftover \n
        System.out.println("Name: '" + buggyName + "'");  // Empty!

        // --- THE FIX ---
        System.out.println("\n=== With fix ===");
        System.out.print("Enter roll number: ");
        int roll2 = sc.nextInt();
        sc.nextLine(); // Consume the leftover newline
        System.out.print("Enter name: ");
        String fixedName = sc.nextLine();  // Now reads correctly
        System.out.println("Name: '" + fixedName + "'");

        sc.close();
    }
}

import java.util.Scanner;

public class ParseLineApproach {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.print("Enter your age: ");
        int age = Integer.parseInt(sc.nextLine().trim());

        System.out.print("Enter your CGPA: ");
        double cgpa = Double.parseDouble(sc.nextLine().trim());

        System.out.print("Enter your name: ");
        String name = sc.nextLine();

        System.out.println(name + ", Age: " + age + ", CGPA: " + cgpa);
        sc.close();
    }
}

import java.util.Scanner;

public class InputValidation {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

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

        if (sc.hasNextInt()) {
            int num = sc.nextInt();
            System.out.println("You entered: " + num);
            System.out.println("Doubled: " + (num * 2));
        } else {
            System.out.println("Invalid input. Expected an integer.");
        }

        sc.close();
    }
}

import java.util.Scanner;

public class TryWithResources {
    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            System.out.print("Enter first number: ");
            int a = sc.nextInt();

            System.out.print("Enter second number: ");
            int b = sc.nextInt();

            System.out.println("Sum: " + (a + b));
        } // Scanner is automatically closed here

        System.out.println("Scanner has been closed automatically.");
    }
}

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

public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(
            new InputStreamReader(System.in)
        );

        System.out.print("Enter your name: ");
        String name = br.readLine();

        System.out.print("Enter two numbers (space-separated): ");
        String[] parts = br.readLine().split(" ");
        int a = Integer.parseInt(parts[0]);
        int b = Integer.parseInt(parts[1]);

        System.out.println("Hello " + name + "!");
        System.out.println(a + " + " + b + " = " + (a + b));

        br.close();
    }
}

Common Mistakes

Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
String name = sc.nextLine();  // Reads empty string!
System.out.println("Name: " + name);

Scanner sc = new Scanner(System.in);
int age = sc.nextInt();
sc.nextLine();  // Consume leftover newline
String name = sc.nextLine();
System.out.println("Name: " + name);

Scanner sc = new Scanner(System.in);
System.out.print("Enter city: ");
String city = sc.next();  // User types: New Delhi
System.out.println("City: " + city);  // Prints: City: New

Scanner sc = new Scanner(System.in);
System.out.print("Enter city: ");
String city = sc.nextLine();  // Reads entire line
System.out.println("City: " + city);  // Prints: City: New Delhi

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);  // ERROR
    }
}

import java.util.Scanner;  // Add this import

public class Demo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
    }
}

Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
int num = sc.nextInt();  // User types: hello

Scanner sc = new Scanner(System.in);
System.out.print("Enter a number: ");
if (sc.hasNextInt()) {
    int num = sc.nextInt();
    System.out.println("Number: " + num);
} else {
    System.out.println("Invalid input. Please enter an integer.");
    sc.next();  // Consume the invalid token
}

Scanner sc1 = new Scanner(System.in);
int x = sc1.nextInt();
sc1.close();  // Closes System.in!

Scanner sc2 = new Scanner(System.in);  // System.in is already closed
int y = sc2.nextInt();  // ERROR at runtime

Scanner sc = new Scanner(System.in);  // One Scanner for the whole program
int x = sc.nextInt();
int y = sc.nextInt();
sc.close();  // Close once at the end

Summary