You could take the first character from Scanner.next:

char c = reader.next().charAt(0);

To consume exactly one character you could use:

char c = reader.findInLine(".").charAt(0);

To consume strictly one character you could use:

char c = reader.next(".").charAt(0);

nextLine() reads the remainder of the current line even if it is empty.

Correct.

nextInt() reads an integer but does not read the escape sequence "\n".

Correct¹.

next() reads the current line but does not read the "\n".

Incorrect. In fact, the next() method reads the next complete token. That may or may not be the rest of the current line. And it may, or may not consume an end-of line, depending on where the end-of-line is. The precise behavior is described by the javadoc, and you probably need to read it carefully for yourself in order that you can fully understand the nuances.

So, in your example:

1. The nextInt() call consumes the 2 character and leaves the position at the NL.

2. The next() call skips the NL, consumes H and i, and leaves the cursor at the second NL.

3. The nextLine() call consumes the rest of the 2nd line; i.e. the NL.

Note that the above assumes that you are using the default delimiter. (As your example does.) If you change the scanner's delimiter by calling one of the useDelimiter(...) methods, you can cause (for example) next() to return newline characters as part of a token.

^{1 ... except that your terminology is wrong. When the data is being read, it is not an escape sequence. It is an end-of-line sequence that could consist of a CR, a NL or a CR NL depending on the platform. The escape sequences you are talking about are in Java source code, in string and character literals. They may >>represent<< a CR or NL or ... other characters.}

That's because the Scanner.nextInt method does not read the newline character in your input created by hitting "Enter" and so the call to Scanner.nextLine returns after reading that newline.

You will encounter the similar behaviour when you use Scanner.nextLine after Scanner.next() or any Scanner.nextFoo method (except nextLine itself).

Workaround:

• Either put a Scanner.nextLine call after each Scanner.nextInt or Scanner.nextFoo to consume the rest of that line including newline:

   int option = input.nextInt();
   input.nextLine();  // Consume left over newline
   String str1 = input.nextLine();
  

• Or, even better, read the input through Scanner.nextLine and convert your input to the proper format you need. For example, you may convert to an integer using the Integer.parseInt(String) method:

   int option = 0;
   try {
       option = Integer.parseInt(input.nextLine());
   } catch (NumberFormatException e) {
       e.printStackTrace();
   }
   String str1 = input.nextLine();