Java User Input – Scanner Class
The most common way to take user input in Java is using the Scanner class. It is a part of java.util package. The scanner class can handle input from different places, like as we are typing at the console, reading from a file, or working with data streams. This class was introduced in Java 5. Before that, we used the BufferedReader class (introduced in Java 1.1). As a beginner, we will suggest to use Scanner class.
Using Scanner in Our Code
Follow these steps to take user input using Scanner class:
- Import the Scanner class using import java.util.Scanner;
- Create the Scanner object and connect Scanner with System.in by passing it as an argument i.e., Scanner sc = new Scanner(System.in);
- When we want to ask the user for input, first print a prompt message so they know what to enter. Then use one of Scanner’s handy methods to read the response:
- nextInt() for whole numbers
- nextLine() for full text lines
- nextDouble() for decimal numbers
- next() for single words
Example: Let us go through a simple example where we get two numbers from the user and add them together:
// Taking user input
import java.util.Scanner;
class Geeks
{
public static void main(String[] args)
{
// Creating Scanner class object
Scanner scn = new Scanner(System.in);
// Enter first input
System.out.print("Enter First Number: ");
int a = scn.nextInt();
System.out.print("Enter Second Number: ");
int b = scn.nextInt();
System.out.println("Sum: " + (a + b));
// Closing the scanner to release resources
scn.close();
}
}
Output:

Methods of Scanner Class
We have discussed few methods of Scanner class above, but the Scanner class provides some more methods to read different data types, let us discuss those in the below table:
Method | Description |
---|---|
Used for reading Boolean value. | |
Used for reading Byte value. | |
Used for reading Double value. | |
Used for reading Float value. | |
Used for reading Int value. | |
Used for reading Line value. | |
Used for reading Long value. | |
Used for reading Short value. |
Example: Here, we are taking multiple user inputs like string, float, double etc. and using the above mentioned methods of Scanner Class.
// Taking multiple user input using Scanner Class
import java.util.Scanner;
public class Geeks
{
public static void main(String[] args)
{
// Scanner definition
Scanner scn = new Scanner(System.in);
// input is a string(one word)
System.out.print("Enter a word: ");
String str1 = scn.nextLine();
System.out.println("Entered String str1: " + str1);
// input is a string(complete sentence)
System.out.print("Enter a sentence: ");
String str2 = scn.nextLine();
System.out.println("Entered String str2: " + str2);
// input is an integer
System.out.print("Enter an integer: ");
int x = Integer.parseInt(scn.nextLine());
System.out.println("Entered Integer: " + x);
// input is a float value
System.out.print("Enter a float value: ");
float f = Float.parseFloat(scn.nextLine());
System.out.println("Entered FloatValue: " + f);
scn.close();
}
}
Output:

2
Another method to take user input is using BufferedReader Class. It is a simple class that is used to read a sequence of characters. It provides several methods, including:
- read(): Reads a single character.
- read(char[] cbuf): Reads an array of characters.
- readLine(): Reads an entire line of text.
To know more about BufferedReader Class, please refer to the article – BufferedReader Class in Java
BufferedReader vs Scanner Class
Aspects | BufferedReader | Scanner |
---|---|---|
Primary Use | Efficient reading of character streams. | Reading formatted input (e.g., integers, strings). |
Speed | Faster for large input as it does less parsing. | Slower due to parsing overhead (e.g., nextInt(), nextFloat()). |
Exception Handling | Throws checked exceptions (e.g., IOException). | No checked exceptions; easier to use. |
Flexibility | Allows reading larger input efficiently. | Best suited for reading simple data types. |
Thread Safety | Synchronized, making it thread-safe. | Not thread-safe by default. |
Common Use | Used for reading large input efficiently. | Commonly used for smaller, formatted input. |