Accepting Java user input is a core component of creating interactive programs. From a console-based tool to a form-based system and even a game, knowing how to read and handle user input in Java is very important. Java offers a number of methods – Scanner, BufferedReader, and Console – to read various kinds of input such as strings, numbers, and characters. In this article, we will learn how to get input from users in Java, along with examples, best practices, and common pitfalls for beginner and advanced programmers alike who work with Java user input to write interactive and responsive Java programs.
Table of Contents:
User input in Java is the process of getting input entered by a user when the program is running. Java offers a number of methods for reading user input, the most used being the keyboard (console input).
The input is used for creating interactive programs, such as prompting a user for their name, age, or any other information that the program will process.
You can allow Java user inputs using three basic methods:
- Scanner (from java.util package): Simplest and most widely used for novices.
- BufferedReader (from java.io package): More efficient for reading large amounts of data or many lines.
- Console (from java.io.Console): Is helpful in command-line programs but not supported in all environments (such as IDEs).
Each of these methods has different uses based on performance, simplicity, and environmental compatibility.
The developers can take user input in Java using three different methods, i.e., Scanner, BufferedReader, and Console. The Scanner class is easy and reads the input from different data types such as integers, doubles, and strings. The BufferedReader class is faster and efficient for large inputs, but it requires manual conversion as throughput only comes in the form of a string. The Console class is used for secure input, such as passwords.
1. Scanner class in Java
The most common way to take the user input in Java is by using the Scanner class, which is found in the java.util package. The scanner class can read the input value from the console, files, or streams. Before Java 5, the BufferedReader class was used
This class does not require any downloads or installations. It is designed to read the primitive data types and strings by using regular expressions. This means that it can automatically interpret the input text like integers, double values, and strings. It works in all environments, including IDEs.
To read input from the file, we can pass the object of the Scanner class to a file. The Scanner class reads an entire line and then divides it into tokens. Tokens are small elements that have some meaning to the Java compiler.
For example, suppose there is an input string: “How are you?”
The scanner object will read the entire line and will divide the string into tokens, i.e., “How”, “are”, and “you”. Then the object goes to each token and reads it using the different methods. This is how Java user inputs are read using the Scanner Class. Now, let us look at how you can incorporate this code in your Java code, step by step.
The following are the steps to take user input in Java using the Scanner class:
1. Import the Scanner class using import java.util.Scanner;
import java.util.Scanner;
2. Create the Scanner object and connect the Scanner with System.in by passing it as an argument, i.e.
Scanner scn = new Scanner(System.in);
3. Prompt the user for input by displaying a message.
4. Use appropriate Scanner methods to read input based on the data type required. Like nextInt(), nextLine(), next(),or nextDouble()
5. Close the Scanner to free up the resources
scn.close();
Note: The Scanner class should be closed when it is not needed because it helps free up resources. Be careful while closing the scanner class, as when it is closed, it will also close the System.in, which can affect the other parts of the program that will read input from the console.
Methods of the Scanner Class
The Scanner class provides various methods to read different Java user inputs:
| Method |
Description |
| nextBoolean() |
Reads a boolean value (true or false). |
| nextByte() |
Reads a byte value. |
| nextDouble() |
Reads a double (decimal) value. |
| nextFloat() |
Reads a float (decimal) value. |
| nextInt() |
Reads an int (integer) value. |
| nextLine() |
Reads an entire line of text. |
| nextLong() |
Reads a long (large integer) value. |
| nextShort() |
Reads a short (small integer) value. |
| next() |
Reads a single word (until space). |
| nextBigInteger() |
Reads a BigInteger value. |
| nextBigDecimal() |
Reads a BigDecimal value. |
| hasNext() |
Checks if there is another token in the input. |
| hasNextBoolean() |
Checks if the next token is a boolean. |
| hasNextByte() |
Checks if the next token is a byte. |
| hasNextDouble() |
Checks if the next token is a double. |
| hasNextFloat() |
Checks if the next token is a float. |
| hasNextInt() |
Checks if the next token is an int. |
| hasNextLine() |
Checks if there is another line of input. |
| hasNextLong() |
Checks if the next token is a long. |
| hasNextShort() |
Checks if the next token is a short. |
Java Scanner Delimiter
By default, the Scanner class uses whitespace, like spaces and the Enter key, to separate the input value. However, this can be changed by using the useDelimiter() method, which allows developers to define a custom delimiter like commas, semicolons, or any other character according to the type of input you expect from the users.
Example: Using a Comma as a Delimiter
Output:
Explanation: The above code shows how to use a user-defined delimiter by using the Scanner class in Java. The useDelimiter(“,”) function is used to make the comma the delimiter, and then the while loop reads and prints its value.
When we are taking multiple user input in Java, we can add an if statement before each input, which will make the program more lengthy and complex. To reduce this, the Scanner class provides built-in exception handling.
If the input entered by the user cannot be processed correctly, the Scanner method will throw exceptions such as:
- NoSuchElementException: It is thrown when no more input is available, but a method is called to read input.
- InputMismatchException: It is thrown when the input does not match the expected data type, e.g., entering a string when an integer is expected.
By using methods like hasNextInt(), hasNextDouble(), etc., we can check user input in Java before reading it to avoid exceptions.
Example: Handling the Input Mismatch Exception
In the above program, if the user enters an integer, no error message will be displayed, and the program will run successfully, showing the expected output.
However, if the user enters a string instead of an integer, an error message will be displayed as shown below.
2. BufferedReader Class in Java
The BufferedReader class in Java reads a stream of characters from a character-based input stream. It is often used with FileReader or InputStreamReader to improve performance when reading large files or streams. InputStreamReader is a function in Java that converts the input stream into a sequence of characters for BufferedReader to scan and therefore, makes it good to take string user input in Java.
The BufferedReader class uses read() and readLine() methods to read the characters from input.
The following are the steps to take to get user input using the BufferedReader class:
1. Import the BufferedReader class using import java.io.BufferedReader;
import java.io.BufferedReader
2. Create the BufferedReader object
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
3. Read the Input Using readLine()
System.out.print("Enter your name: ");
String name = br.readLine(); // Reads a full line of input
4. Process the Input
System.out.println("Hello, " + name + "! You are " + age + " years old.");
5. Close the BufferedReader to free up the resources
br.close();
Example:
Output:
Explanation: In the above example, user input in Java is taken using the BufferedReader class. Then it asks for the user’s name and reads it as a string. Further, asks for the user’s age, reads it, and converts it to an integer. Finally, it prints a greeting message and closes the BufferedReader.
Get 100% Hike!
Master Most in Demand Skills Now!
Methods of the BufferedReader Class
The following is the list of the table, which shows the methods that the buffered reader uses to read Java user inputs:
| Method |
Description |
| readLine() |
Reads a full line of text as a string. |
| read() |
Reads a single character as an integer. Returns -1 if it reaches the end of the stream. |
| skip(long n) |
Skips n characters while reading. |
| ready() |
Returns true if the stream is ready to be read, else false. |
| mark(int limit) |
Marks the current position in the stream. |
| reset() |
Resets the stream. |
| close() |
Closes the BufferedReader to free resources. |
Reading Different Data Types with BufferedReader
As BufferedReader only reads strings, we need to convert the input manually into the other data types. Although it allows other datatype user inputs in Java as well but converting them takes significant amount of time.
Example: Reading an Integer
System.out.print("Enter your age: ");
int age = Integer.parseInt(br.readLine()); // Convert String to int
Example: Reading a Double
System.out.print("Enter your salary: ");
double salary = Double.parseDouble(br.readLine()); // Convert String to double
1. Faster Input Handling: It efficiently reads and handles the user input in Java faster than any other class.
2. Efficient for Large Data: It is suitable for reading large files and processing large inputs.
3. Reads Full Lines: It can read the entire line using the readLine() method. This feature was not available in any previous Java user input classes.
4. Less Memory Usage: It uses a buffer to store the input, which reduces the number of interactions with the input stream resulting in less memory usage by the methods that take user input in Java
5. Supports Character Streams: It can handle character-based input, which makes it useful for text processing.
1. Only Reads Strings: It only returns input in the form of strings, which requires manual conversion for numbers for any other data type user input in Java.
2. More Code Required: It needs an extra step to convert the user input data type.
3. No Built-in Input Validation: It does not check for a valid input type when a user input in Java is accepted.
4. Checked Exception Handling: It requires the handling of IOException with try-catch or the throws keyword.
3. Console Class in Java
The Console class in Java is used for reading user input from the system console command-line interface. It is part of the java.io package and is useful for interactive applications.
Advantages of the console class
1. Secure Input Handling: It allows the user to securely input the password. The readPassword() method allows users to input passwords without displaying them on the screen, which will make it secure.
2. Ideal for Command-Line Applications: It works well in a terminal like Command Prompt, Terminal, and PowerShell. It is good for applications where IDEs are not required, e.g., remote server applications
Disadvantages of Console Class
1. Does Not Work in IDEs: In most IDEs like Eclipse, IntelliJ, and NetBeans, System.console() returns null because IDEs do not use a system console to run the Java programs.
2. Limited Input Capabilities: It only returns the String input, i.e., you have to convert it to another data type by using Integer.parseInt(), Double.parseDouble(), etc.
Example:
Output:
BufferedReader vs Scanner vs Console Class in Java
Now that we have discussed all the three methods extensively, Let us look at their differences based on many features in Java.
| Feature |
BufferedReader |
Scanner |
| Speed |
Faster (uses buffering) |
Slower (token-based) |
| Ease of Use |
Requires manual conversion |
Easy to use |
| Reads Data |
Only strings (needs conversion) |
Strings, numbers, booleans |
| Best For |
Large files, performance |
General user input |
| Exception Handling |
Requires try-catch (IOException) |
Built-in exception handling |
| Memory Usage |
Low (uses buffering) |
Higher (parses input) |
| Methods |
readLine() |
nextInt(), nextLine(), nextDouble(), etc. |
When working with Java user input, choosing the right method and following best practices helps improve performance, security, and reliability. Here are some essential guidelines:
- Handling multiple inputs effectively: For cases like how to take multiple inputs in Java, ensure the chosen method can handle space-separated, line-separated, or structured input. BufferedReader with parsing logic is often better for large datasets.
- Always close resources properly: Whether using the Java Scanner class example or Java BufferedReader input, make sure to close the input stream after use. This prevents resource leaks and ensures efficient memory usage.
- Validate input before parsing: Input validation is crucial when learning how to take input in Java from user. For instance, check whether the input is a number, string, or follows the expected format. Proper Java user input validation prevents runtime errors and increases program stability.
- Use Console for sensitive data: For secure Java console input example, prefer
Console.readPassword() instead of Scanner. This ensures that sensitive information like passwords is not echoed on the screen. This aligns with best practices for Java read password console.
- Know when to use next() vs nextLine(): A common confusion in Java input nextLine vs next is that
next() reads only one token, while nextLine() reads the entire line. Understanding the difference avoids bugs where Scanner seems to “skip” inputs.
- Choose the right input method based on performance: If you wonder which is faster Scanner or BufferedReader, remember that BufferedReader is generally faster for bulk input, while Scanner is easier for parsing formatted data.
After understanding the different ways to take input in Java, let’s put them into practice. Below is a simple real-world example of a mini calculator that demonstrate how Scanner, BufferedReader, and Console can be used in everyday applications.
While the same calculator could also be implemented using BufferedReader or Console, Scanner is best suited for small programs and quick user input. Let’s build a simple calculator that takes two numbers and an operator from the user.
Output:
Explanation: Here, since the calculator program is a small program, we used the Scanner class here to take user input in Java.
Free Online Java Certification Course
This free Java course is designed for anyone interested in learning Java and pursuing a career as a Java Developer
Conclusion
Developers can use a Scanner, a BufferedReader, or a Console to read the user input in Java. The Scanner is easy to use and has many data types to read input. The BufferedReader class improves efficiency when reading large inputs, but the data type has to be changed by the user. The Console class handles inputs securely, such as passwords, but does not work in the IDEs.
Useful Resources:
Q1. How to read user input in Java from the system?
To read user input in Java, we commonly use the Scanner class. It provides simple methods like nextInt() and nextLine() to capture different types of user input efficiently.
Q2. How to get Java user input without using a Scanner?
Java user input can also be read using BufferedReader with InputStreamReader. This method is slightly faster than Scanner but requires exception handling and parsing for different data types.
Q3. How to call a method in Java?
Calling a method doesn’t directly involve Java user input, but you can combine them. For instance, after taking user input in Java, you can pass that input as an argument to a method.
Q4. How to read a file using Java user input?
To read a file in Java, classes like BufferedReader, Scanner, or Files.readAllLines() are used. These allow reading content line by line or all at once depending on requirements.
Q5. What is the difference between Scanner and BufferedReader in Java user input?
The Scanner is easier and handles multiple data types directly, while BufferedReader is faster and suitable for large input. BufferedReader requires manual parsing, whereas Scanner provides built-in parsing methods.
Q6. How to access a file using user input in Java?
To access a file using Java user input, you can take the file path from the user via Scanner or BufferedReader and then use File or FileReader classes to process the file.
Q7. How to take multiple inputs in Java?
You can handle multiple user inputs in Java by repeatedly calling the input methods of Scanner or BufferedReader. For example, by looping through nextInt() or nextLine(), programs can collect several pieces of Java user input in sequence.
Q8. Which is faster Scanner or BufferedReader?
In terms of performance, BufferedReader is usually faster than Scanner because it reads text in larger chunks. However, Scanner is more convenient when working with formatted Java user input. Choosing between them depends on whether you prioritize speed or ease of parsing user inputs in Java.
Q9. Why does Scanner skip input in Java?
This happens due to the way Scanner handles newline characters. After methods like nextInt(), the newline is left in the buffer, causing the next nextLine() to appear skipped. Understanding this behavior is important to avoid mistakes when managing Java user input or sequential user inputs in Java.