How to Take Input as String With Spaces in Java Using Scanner?

1. Overview

Taking and parsing user input is a common task in our daily Java programming, and handling input that includes spaces can sometimes be tricky.

In this tutorial, we’ll explore using the Scanner class to take input as a string with spaces in Java.

2. Introduction to the Problem

As usual, let’s understand the problem with a simple example.

Let’s say our scanner receives two lines of text. The first one is a person’s name, and the second line describes the person briefly:

String input = new StringBuilder().append("Michael Jackson\n")
  .append("He was the 'King of Pop'.\n")
  .toString();

Scanner sc = new Scanner(input);

For simplicity, we’ll feed Scanner objects with strings and use unit test assertions to verify if the results are expected.

Usually, we’ll use the Scanner.next() method to read the next token from the scanner.

Next, let’s try to read two tokens from our scanner object:

String name = sc.next();
String description = sc.next();
assertEquals("Michael", name);
assertEquals("Jackson", description);

If we run the test, it passes. Obviously, Scanner doesn’t intelligently understand our requirements. Instead, it uses whitespace, including spaces and line breaks, as the default delimiter to read tokens. Therefore, we’ve got “Michael” instead of “Michael Jackson“ as the person’s name.

Actually, this example presents only one scenario of handling input values containing spaces. There can be two scenarios:

• One value per line, as our “Michael Jackson” example shows
• Values separated by a special separator

Next, we’ll figure out how to read the values containing spaces from a Scanner object. Of course, we’ll cover both scenarios.

3. One Value per Line

Let’s first take a closer look at the “one value per line” scenario. We’ll still use the previous “Michael Jackson” example as the input in this section.

3.1. Using the nextLine() Method

Since we want to read an entire line from the scanner as a value, the Scanner’s nextLine() method is a good choice. The nextLine() method reads from the current position until the next line break:

Scanner sc = new Scanner(input);
String name = sc.nextLine();
String description = sc.nextLine();
assertEquals("Michael Jackson", name);
assertEquals("He was the 'King of Pop'.", description);

As the code above shows, nextLine() solves the problem straightforwardly.

3.2. Using ‘\n‘ as the Delimiter

We’ve mentioned earlier that Scanner treats space and line breaks as delimiters by default. If we tell Scanner only to take the newline character as a delimiter, we can still use the next() method to read a line as a token. Let’s create a test to verify it:

Scanner sc = new Scanner(input);
sc.useDelimiter("\\n");
String name = sc.next();
String description = sc.next();
assertEquals("Michael Jackson", name);
assertEquals("He was the 'King of Pop'.", description);

As we can see, the useDelimiter() method is the key to solving the problem.

4. Values Separated by a Special Separator

Sometimes, our input has a predefined format. For example, a comma and a space separate an input line of three great artists’ names: “Michael Jackson, Whitney Houston, John Lennon“.

Next, let’s see how to read expected values in this scenario.

4.1. Using the String.split() Method

The first idea for solving this problem is still reading the entire line using nextLine(). Then, we can pass the separator pattern to the convenient String.split() method to get the values in an array:

String input = "Michael Jackson, Whitney Houston, John Lennon\n";

Scanner sc = new Scanner(input);
String[] names = sc.nextLine().split(", ");
assertArrayEquals(new String[] { "Michael Jackson", "Whitney Houston", "John Lennon" }, names);

The test above shows we’ve stored the three names in a string array correctly.

4.2. Customizing the Delimiter

The split() with the separator pattern approach can handle values with a custom separator. However, as arrays have fixed sizes in Java, merging arrays can be slow if the scanner input has multiple lines.

Usually, we’d use lists over arrays in Java. So next, let’s adjust the Scanner’s delimiter and store the names in a list using Scanner’s next() method.

We’ve learned to use the useDelimiter() method to set a custom delimiter pattern. Since the separator of this input example is a comma and space, some of us may come up with the idea: useDelimiter(“, “).

So next, let’s add one more name to the input and see if this idea works as expected:

String input = new StringBuilder().append("Michael Jackson, Whitney Houston, John Lennon\n")
  .append("Elvis Presley\n")
  .toString();

Scanner sc = new Scanner(input);
sc.useDelimiter(", ");
List<String> names = new ArrayList<>();
while (sc.hasNext()) {
    names.add(sc.next());
}
assertEquals(Lists.newArrayList("Michael Jackson", "Whitney Houston", "John Lennon", "Elvis Presley"), names);

The test fails if we give it a run. What a surprise! So, let’s figure out what we have in the list through a couple of assertions:

assertEquals(3, names.size());
assertEquals("John Lennon\nElvis Presley\n", names.get(2));

We can see our result list has three elements instead of four. Also the third element is “John Lennon\nElvis Presley\n”. This is because we’ve set “, ” as the delimiter. Then, newlines become parts of a token. So the next() method will treat newlines as other regular characters in the token.

Now we understand the cause of the problem. Then it’s easy to fix – we must add ‘\n‘ to the delimiter pattern:

Scanner sc = new Scanner(input);
sc.useDelimiter(", |\\n");
List<String> names = new ArrayList<>();
while (sc.hasNext()) {
    names.add(sc.next());
}
assertEquals(Lists.newArrayList("Michael Jackson", "Whitney Houston", "John Lennon", "Elvis Presley"), names);

This time, the test passes.

5. Conclusion

In this article, we’ve learned how to read values containing spaces from a Scanner through examples. The article covers two scenarios, and we’ve explored different approaches to solving the problems.