2026-01-267 min read

String Input from the User (Java)

Learn String Input from the User (Java) step by step with clear examples and exercises.

Title: String Input from the User (Java)

Why This Matters

Interacting with users is crucial in programming, allowing for dynamic applications that cater to user preferences and improve overall user experience. In Java, we can read text input from the user using various methods provided by the standard libraries. Understanding these methods will help you create more interactive and responsive programs.

Importance of User Input

Enables users to customize or control the behavior of a program
Allows for dynamic content based on user preferences
Improves user engagement and overall user experience

Prerequisites

To follow this lesson, you should be familiar with:

Basic Java syntax and programming concepts such as variables, data types, operators, and control structures (if-else, loops)
Understanding the concept of classes and objects in Java
Familiarity with the Scanner class and its usage for reading user input
Knowledge of basic string operations in Java (concatenation, substring, etc.)
Comprehension of fundamental data structures like arrays and lists
Understanding exception handling using try-catch blocks

Core Concept

To read text input from the user in Java, we use the Scanner class, which is a part of the java.util package. The Scanner class allows us to read data from various sources such as the keyboard (System.in), files, or even network connections.

Scanner Class Overview

Part of the java.util package
Used for reading user input from various sources
Provides methods for reading different types of data like integers, strings, and more
Offers a convenient way to handle exceptions when reading user input using try-catch blocks

Here's an example of using the Scanner class to read user input:

import java.util.Scanner; // Importing the Scanner class

public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // Creating a Scanner object to read from System.in (keyboard input)

try {
System.out.print("Enter your name: ");
String userName = scanner.nextLine(); // Reading the user's name as a string using the nextLine() method
System.out.println("Hello, " + userName); // Printing a greeting message with the user's name
} catch (Exception e) {
System.err.println("An error occurred while reading input: " + e.getMessage());
} finally {
if (scanner != null) {
scanner.close(); // Closing the Scanner object to free up system resources
}
}
}
}

In this example, we first import the Scanner class from the java.util package. Then, inside the main() method, we create an instance of the Scanner class and enclose the input reading process in a try-catch block to handle any exceptions that may occur during input reading.

Next, we use the print() method to display a prompt message asking the user to enter their name. After that, we call the nextLine() method on the scanner object to read the user's input as a string. If an error occurs while reading the input, it is caught and logged to the console using the printStackTrace() method of the exception object.

Finally, we print a greeting message with the user's name and close the Scanner object in the finally block to free up system resources.

Reading Different Data Types

nextInt(): Reads an integer value
nextDouble(): Reads a double value
nextBoolean(): Reads a boolean value
... and more for other data types

Worked Example

Let's create a simple Java program that reads two strings, an integer, and a floating-point number from the user, performs calculations on them, and displays the results:

import java.util.Scanner;

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

System.out.print("Enter the first string: ");
String str1 = scanner.nextLine();
System.out.print("Enter the second string: ");
String str2 = scanner.nextLine();

System.out.print("Enter an integer: ");
int number1 = scanner.nextInt();
System.out.print("Enter a floating-point number: ");
double number2 = scanner.nextDouble();

String concatenatedString = str1 + " " + str2;
double averageNumber = (number1 + number2) / 2.0;

System.out.println("The concatenated string is: " + concatenatedString);
System.out.println("The average of the numbers you entered is: " + averageNumber);
}
}

In this example, we create a program named CalculatorExample. Inside the main() method, we first create an instance of the Scanner class and then ask the user to enter two strings. We read each string using the nextLine() method and store them in separate variables (str1 and str2).

Next, we ask the user to enter an integer and a floating-point number. We read these values using the nextInt() and nextDouble() methods provided by the Scanner class, respectively.

After that, we concatenate the two strings with a space between them and store the result in a variable (concatenatedString). Then, we calculate the average of the two numbers entered by the user and store it in another variable (averageNumber).

Finally, we print the concatenated string and the average number using the println() method.

Common Mistakes

Forgetting to import Scanner: Remember to import the Scanner class from the java.util package at the beginning of your program.
Not flushing the buffer: When reading user input using the nextLine() method, it's essential to add a newline character (\n) after each print statement or else the buffer may not be flushed properly. This can cause the next input to be read incorrectly.
Reading integers with nextLine(): The nextLine() method reads strings, so if you try to use it for reading integers, you'll encounter errors. Instead, use the nextInt() or other appropriate methods provided by the Scanner class for reading numeric input.
Not closing the Scanner object: Although not necessary in most cases, it's a good practice to close the Scanner object once you're done using it to free up system resources. You can do this by calling the close() method on the scanner object.
### Subheadings under Common Mistakes:

Not flushing the buffer: Explain why flushing the buffer is important and how to avoid common issues with it.
Reading integers with nextLine(): Discuss the consequences of using nextLine() for reading integers and suggest alternative methods.
Not closing the Scanner object: Emphasize the importance of freeing up system resources by closing the Scanner object and provide examples on how to do it.

Practice Questions

Write a program that reads three integers from the user and calculates their average.
Modify the CalculatorExample program to read two strings, reverse them individually, and print the reversed strings separately.
Create a program that asks the user for their name and age, checks if they are eligible to vote (18 or older), and prints an appropriate message based on their eligibility status.
Write a program that reads a line of text from the user and counts the number of vowels in it.
Write a program that reads a string from the user, removes all duplicate characters, and sorts the remaining characters in alphabetical order.
Write a program that reads two strings from the user, concatenates them, and finds the longest common substring between the resulting string and each original input string.
Write a program that reads a string from the user, checks if it's a palindrome (reads the same forwards and backwards), and prints whether it is or isn't a palindrome.
Write a program that reads a list of integers from the user using an ArrayList, calculates their sum, and prints the result.
Write a program that reads two arrays of strings from the user and finds the union (all unique elements combined) of both arrays.
Write a program that reads two arrays of integers from the user, sorts them in ascending order, and merges the sorted arrays into one array.

FAQ

Why do I need to add a newline character after each print statement?

When you print something using System.out.print() or System.out.println(), the output is buffered until a newline character (\n) is encountered. If you don't add a newline character after your print statements, the user might not be prompted to enter their input immediately, causing issues with the program's flow.

What happens if I try to read integers using nextLine()?

Reading integers using nextLine() will result in an error because this method is designed for reading strings. To read integers, use the appropriate methods provided by the Scanner class such as nextInt().

Why should I close the Scanner object after using it?

Closing the Scanner object helps to free up system resources that are being used to read input from the specified source (e.g., keyboard). Although not necessary in most cases, it's a good practice to get into for efficient resource management.

What is the difference between nextLine() and next()?

nextLine() reads the entire line as a string, while next() reads the next token (word) as a string. Using next() requires splitting the input using the split() method or other methods to separate words.

Why does my program sometimes read incorrect user input?

Incorrect user input can occur due to various reasons, such as not flushing the buffer properly or reading numeric input with nextLine(). To avoid these issues, make sure to follow best practices for handling user input and use appropriate methods provided by the Scanner class.