1. Overview
When we write Java applications to accept users’ input, there could be two variants: single-line input and multiple-line input.
In the single-line input case, it’s pretty straightforward to handle. We read the input until we see the line break. However, we need to manage multiple-line user input in a different way.
In this tutorial, we’ll address how to handle multiple-line user input in Java.
2. The Idea to Solve the Problem
In Java, we can read data from user input using the Scanner class. Therefore, reading data from user input isn’t a challenge for us. However, if we allow users to input multiple lines of data, we should know when the user has given all the data that we should accept. In other words, we need an event to know when we should stop reading from user input.
A commonly used approach is we check the data that the user sends. If the data match a defined condition, we stop reading input data. In practice, this condition can vary depending on the requirement.
An idea to solve the problem is writing an infinite loop to keep reading user input line by line. In the loop, we check each line the user sends. Once the condition is met, we break the infinite loop:
while (true) {
String line = ... //get one input line
if (matchTheCondition(line)) {
break;
}
... save or use the input data ...
}
Next, let’s create a method to implement our idea.
3. Solving the Problem Using an Infinite Loop
For simplicity, in this tutorial, once our application receives the string “bye” (case-insensitive), we stop reading the input.
Therefore, following the idea we’ve talked about previously, we can create a method to solve the problem:
public static List<String> readUserInput() {
List<String> userData = new ArrayList<>();
System.out.println("Please enter your data below: (send 'bye' to exit) ");
Scanner input = new Scanner(System.in);
while (true) {
String line = input.nextLine();
if ("bye".equalsIgnoreCase(line)) {
break;
}
userData.add(line);
}
return userData;
}
As the code above shows, the readUserInput method reads user input from System.in and stores the data in the userData List.
Once we receive “bye” from the user, we break the infinite while loop. In other words, we stop reading user input and return userData for further processing.
Next, let’s call the readUserInput method in the main method:
public static void main(String[] args) {
List<String> userData = readUserInput();
System.out.printf("User Input Data:\n%s", String.join("\n", userData));
}
As we can see in the main method, after we call readUserInput, we print out the received user input data.
Now, let’s start the application to see if it works as expected.
When the application starts, it waits for our input with the prompt:
Please enter your data below: (send 'bye' to exit)
So, let’s send some text and send “bye” at the end:
Hello there,
Today is 19. Mar. 2022.
Have a nice day!
bye
After we input “bye” and press Enter, the application outputs the user input data we’ve gathered and exits:
User Input Data:
Hello there,
Today is 19. Mar. 2022.
Have a nice day!
As we have seen, the method works as expected.
4. Unit Testing the Solution
We’ve solved the problem and tested it manually. However, we may need to adjust the method to adapt to some new requirements from time to time. Therefore, it would be good if we could test the method automatically.
Writing a unit test to test the readUserInput method is a bit different from regular tests. This is because when the readUserInput method gets invoked, the application is blocked and waiting for user input.
Next, let’s see the test method first, and then we’ll explain how the problem is solved:
@Test
public void givenDataInSystemIn_whenCallingReadUserInputMethod_thenHaveUserInputData() {
String[] inputLines = new String[]{
"The first line.",
"The second line.",
"The last line.",
"bye",
"anything after 'bye' will be ignored"
};
String[] expectedLines = Arrays.copyOf(inputLines, inputLines.length - 2);
List<String> expected = Arrays.stream(expectedLines).collect(Collectors.toList());
InputStream stdin = System.in;
try {
System.setIn(new ByteArrayInputStream(String.join("\n", inputLines).getBytes()));
List<String> actual = UserInputHandler.readUserInput();
assertThat(actual).isEqualTo(expected);
} finally {
System.setIn(stdin);
}
}
Now, let’s walk through the method quickly and understand how it works.
At the very beginning, we’ve created a String array inputLines to hold the lines we want to use as the user input. Then, we’ve initialized the expected List, containing the expected data.
Next, the tricky part comes. After we backup the current System.in an object in the stdin variable, we’ve reassigned the system standard input by calling the System.setIn method.
In this case, we want to use the inputLines array to simulate the user input.
Therefore, we’ve converted the array to InputStream, a ByteArrayInputStream object in this case, and reassigned the InputStream object as the system standard input.
Then, we can call the target method and test if the result is as expected.
Finally, we shouldn’t forget to restore the original stdin object as the system standard input. Therefore, we put System.setIn(stdin); in a finally block, to make sure it’ll get executed anyway.
It’ll pass without any manual intervention if we run the test method.
5. Conclusion
In this article, we’ve explored how to write a Java method to read user input until a condition is met.
The two key techniques are:
- Using the Scanner class from the standard Java API to read user input
- Checking each input line in an infinite loop; if the condition is met, break the loop
Further, we’ve addressed how to write a test method to test our solution automatically.
As always, the source code used in this tutorial is available over on GitHub.
