I am using Scanner methods nextInt() and nextLine() for reading input. Basically, it looks like this:

System.out.println("enter numerical value");    
int option;
option = input.nextInt();//read numerical value from input
System.out.println("enter 1st string"); 
String string1 = input.nextLine();//read 1st string (this is skipped)
System.out.println("enter 2nd string");
String string2 = input.nextLine();//read 2nd string (this appears right after reading numerical value)

The problem is that after entering the numerical value, the first input.nextLine() is skipped and the second input.nextLine() is executed, so that my output looks like this:

Enter numerical value
3   //this is my input
enter 1st string    //the program is supposed to stop here and wait for my input, but is skipped
enter 2nd string    //and this line is executed and waits for my input

I tested my application and it looks like the problem lies in using input.nextInt(). If I delete it, then both string1 = input.nextLine() and string2 = input.nextLine() are executed as I want them to be.

4 upvote
  flag
23 upvote
  flag
The newline character is probably not consumed. – Lews Therin
5 upvote
  flag
Style note: you should declare your String variables on the same line you assign a value. E.g. String string1 = input.nextLine (). – Duncan Jones
2 upvote
  flag
@Lews Therin: Yes, you are right. After another couple of test I found that it is executed and read "\n". How to avoid of that? – blekione
3 upvote
  flag
Or you could be like me and use BufferedReader :) I don't care if it's old school, it has always worked and always will work for me. Also, knowledge of BufferedReader has application elsewhere. I simply don't like Scanner. – Cruncher

15 Answers 11

The problem is with the input.nextInt() method - it only reads the int value. So when you continue reading with input.nextLine() you receive the "\n" Enter key. So to skip this you have to add the input.nextLine(). Hope this should be clear now.

Try it like that:

System.out.print("Insert a number: ");
int number = input.nextInt();
input.nextLine(); // This line you have to add (It consumes the \n character)
System.out.print("Text1: ");
String text1 = input.nextLine();
System.out.print("Text2: ");
String text2 = input.nextLine();
upvote
  flag
umm seems a solution, making the skipped line non-used nextLine, but I still need an explanation of this behaviour – Eng.Fouad
2 upvote
  flag
upvote
  flag
This is a very simple explanation.. Thanks! – Taslim

It's because when you enter a number then press Enter, input.nextInt() consumes only the number, not the "end of line". When input.nextLine() executes, it consumes the "end of line" still in the buffer from the first input.

Instead, use input.nextLine() immediately after input.nextInt()

upvote
  flag
Mmm, that bug was corrected in now a days? – Victor
5 upvote
  flag
@Victor it's not bug. it's working as specified. you could argue though that there should be an easy way to tell the api to also consume any whitespace following the target input. – Bohemian
upvote
  flag
I see. thanks @Bohemian, that exactly what i am arguing. I think that this should be changed, perhaps you can point me where to suggest this "issue" in the next JCP. – Victor
upvote
  flag
@victor You can request (and find out how to contribute code to) a feature via the Report a Bug or Request a Feature page. – Bohemian
upvote
  flag
up vote 488 down vote accepted

That's because the Scanner.nextInt method does not consume the last newline character of your input, and thus that newline is consumed in the next call to Scanner.nextLine.

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

Workaround:

  • Either fire a blank Scanner.nextLine call after Scanner.nextInt or Scanner.nextFoo to consume rest of that line including newline

    int option = input.nextInt();
    input.nextLine();  // Consume newline left-over
    String str1 = input.nextLine();
    
  • Or, it would be even better, if you read the input through Scanner.nextLine and convert your input to the proper format you need. For examples, to an integer using Integer.parseInt(String) method.

    int option = 0;
    try {
        option = Integer.parseInt(input.nextLine());
    } catch (NumberFormatException e) {
        e.printStackTrace();
    }
    String str1 = input.nextLine();
    
10 upvote
  flag
Both solutions works perfect. As you suggested I will try to use 2nd one, but I have to find out first what mean try and catch. This is something new for me. Thx for help guys. I'm impressed how quick you responded – blekione
5 upvote
  flag
@blekione. Then probably leave it for now. They are used for Exception Handling, which you will learn later on. For now, use the first approach. – Rohit Jain
upvote
  flag
Couldn't I use only option = Integer.parseInt(input.nextLine());} instead of full try{...}? Is there any weakness of using only above? – blekione
3 upvote
  flag
@blekione. You have to use try-catch, because Integer.parseInt throws NumberFormatException when an invalid argument is passed to it. You will learn about exception later on. For E.G: - Integer.parseInt("abc"). You don't want "abc" to get converted to int right? – Rohit Jain
3 upvote
  flag
@blekione. So, in the above case, your code will halt at that point, and you won't be able to continue the execution. With Exception Handling, you can handle such kind of conditions. – Rohit Jain
2 upvote
  flag
To which extent is the latter better? AFAIK Scanner#nextInt() is way more lenient in finding correct ints, by allowing group commas and locale prefixes and suffixes. Integer#parseInt() allows digits and decimal point only plus an optional sign. – MouseEvent
upvote
  flag
I personally prefer a Scanner#hasNextFoo check beforehand instead of a try-catch, but that works too. – Mistah Figgins
upvote
  flag
Scanner scan = new Scanner(System.in); int i = scan.nextInt(); Double d = scan.nextDouble(); int option = 0; try { option = Integer.parseInt(scan.nextLine()); } catch (NumberFormatException e) { //e.printStackTrace(); } String str = scan.nextLine(); System.out.println("String: " + str); System.out.println("Double: " + d); System.out.println("Int: " + i); – priya raj
upvote
  flag
Use ParseDouble has a new problem, that nextDouble use the regional configuration of decimal (. or ,) but Parsedouble always receive US decimal ( . ). – olmerg

It does that because input.nextInt(); doesn't capture the newline. you could do like the others proposed by adding an input.nextLine(); underneath.
Alternatively you can do it C# style and parse a nextLine to an integer like so:

int number = Integer.parseInt(input.nextLine()); 

Doing this works just as well, and it saves you a line of code.

There seem to be many questions about this issue with java.util.Scanner. I think a more readable/idiomatic solution would be to call scanner.skip("[\r\n]+") to drop any newline characters after calling nextInt().

EDIT: as @PatrickParker noted below, this will cause an infinite loop if user inputs any whitespace after the number. See their answer for a better pattern to use with skip: //allinonescript.com/a/42471816/143585

upvote
  flag
upvote
  flag
I know what we do to remove the data in buffer, but this case, please help me with this: //allinonescript.com/questions/33585314/having-issues-with-scan‌​ner – Khuong
upvote
  flag
FYI, this will cause an infinite loop is the user types any tabs or spaces after the numeric input. See my answer here for a better skip: //allinonescript.com/a/42471816/7098259 – Patrick Parker
upvote
  flag
@PatrickParker: it does indeed cause an infinite loop! Thanks, edited the answer to link to yours. – Denis Tulskiy
upvote
  flag
@PatrickParker Why does is cause infinite loop ? – Piyush
upvote
  flag
@Piyush if you have a new question then post a new question. – Patrick Parker

Instead of input.nextLine() use input.next(), that should solve the problem.

Modified code:

public static Scanner input = new Scanner(System.in);

public static void main(String[] args)
{
    System.out.print("Insert a number: ");
    int number = input.nextInt();
    System.out.print("Text1: ");
    String text1 = input.next();
    System.out.print("Text2: ");
    String text2 = input.next();
}

Why not use a new Scanner for every reading? Like below. With this approach you will not confront your problem.

int i = new Scanner(System.in).nextInt();
1 upvote
  flag
But then you have to close the Scanner to prevent memory leak. Wasting time? – TheCoffeeCup
upvote
  flag
Doesn't the GC take care of that if the Scanner is wrapped in a method? Like: String getInput() {return new Scanner(System.in).nextLine()}; – Tobias Johansson
upvote
  flag
This is absolutely incorrect. nextInt() won't consume the newline, regardless of whether it's in a "new" Scanner or an already used one. – Dawood ibn Kareem

Things you need to know:

  • text which represents few lines also contains non-printable characters between lines (we call them line separators) like

    • carriage return (CR - in String literals represented as "\r")
    • line feed (LF - in String literals represented as "\n")
  • when you are reading data from the console, it allows the user to type his response and when he is done he needs to somehow confirm that fact. To do so, the user is required to press "enter"/"return" key on the keyboard.

    What is important is that this key beside ensuring placing user data to standard input (represented by System.in which is read by Scanner) also sends OS dependant line separators (like for Windows \r\n) after it.

    So when you are asking the user for value like age, and user types 42 and presses enter, standard input will contain "42\r\n".

Problem

Scanner#nextInt (and other Scanner#nextType methods) doesn't allow Scanner to consume these line separators. It will read them from System.in (how else Scanner would know that there are no more digits from the user which represent age value than facing whitespace?) which will remove them from standard input, but it will also cache those line separators internally. What we need to remember, is that all of the Scanner methods are always scanning starting from the cached text.

Now Scanner#nextLine() simply collects and returns all characters until it finds line separators (or end of stream). But since line separators after reading the number from the console are found immediately in Scanner's cache, it returns empty String, meaning that Scanner was not able to find any character before those line separators (or end of stream).
BTW nextLine also consumes those line separators.

Solution

So when you want to ask for number and then for entire line and avoid that empty string as result of nextLine, either

  • after nextInt place additional nextLine call to consume line separators from Scanners cache,
  • don't use nextInt (nor next, or any nextTYPE methods) at all. Instead read entire data line-by-line using nextLine and parse numbers from each line (assuming one line contains only one number) to proper type like int via Integer.parseInt.

BTW: Scanner#nextType methods can skip delimiters (by default all whitespaces like tabs, line separators) including those cached by scanner, until they will find next non-delimiter value (token). Thanks to that for input like "42\r\n\r\n321\r\n\r\n\r\nfoobar" code

int num1 = sc.nextInt();
int num2 = sc.nextInt();
String name = sc.next();

will be able to properly assign num1=42 num2=321 name=foobar.

upvote
  flag
good explanation with example. +1 – syadav

In order to avoid the issue, use nextLine(); immediately after nextInt(); as it helps in clearing out the buffer. When you press ENTER the nextInt(); does not capture the new line and hence, skips the Scanner code later.

Scanner scanner =  new Scanner(System.in);
int option = scanner.nextInt();
scanner.nextLine(); //clearing the buffer

If you want to scan input fast without getting confused into Scanner class nextLine() method , Use Custom Input Scanner for it .

Code :

class ScanReader {
/**
* @author Nikunj Khokhar
*/
    private byte[] buf = new byte[4 * 1024];
    private int index;
    private BufferedInputStream in;
    private int total;

    public ScanReader(InputStream inputStream) {
        in = new BufferedInputStream(inputStream);
    }

    private int scan() throws IOException {
        if (index >= total) {
            index = 0;
            total = in.read(buf);
            if (total <= 0) return -1;
        }
        return buf[index++];
    }
    public char scanChar(){
        int c=scan();
        while (isWhiteSpace(c))c=scan();
        return (char)c;
    }


    public int scanInt() throws IOException {
        int integer = 0;
        int n = scan();
        while (isWhiteSpace(n)) n = scan();
        int neg = 1;
        if (n == '-') {
            neg = -1;
            n = scan();
        }
        while (!isWhiteSpace(n)) {
            if (n >= '0' && n <= '9') {
                integer *= 10;
                integer += n - '0';
                n = scan();
            }
        }
        return neg * integer;
    }

    public String scanString() throws IOException {
        int c = scan();
        while (isWhiteSpace(c)) c = scan();
        StringBuilder res = new StringBuilder();
        do {
            res.appendCodePoint(c);
            c = scan();
        } while (!isWhiteSpace(c));
        return res.toString();
    }

    private boolean isWhiteSpace(int n) {
        if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1) return true;
        else return false;
    }

    public long scanLong() throws IOException {
        long integer = 0;
        int n = scan();
        while (isWhiteSpace(n)) n = scan();
        int neg = 1;
        if (n == '-') {
            neg = -1;
            n = scan();
        }
        while (!isWhiteSpace(n)) {
            if (n >= '0' && n <= '9') {
                integer *= 10;
                integer += n - '0';
                n = scan();
            }
        }
        return neg * integer;
    }

    public void scanLong(long[] A) throws IOException {
        for (int i = 0; i < A.length; i++) A[i] = scanLong();
    }

    public void scanInt(int[] A) throws IOException {
        for (int i = 0; i < A.length; i++) A[i] = scanInt();
    }

    public double scanDouble() throws IOException {
        int c = scan();
        while (isWhiteSpace(c)) c = scan();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = scan();
        }
        double res = 0;
        while (!isWhiteSpace(c) && c != '.') {
            if (c == 'e' || c == 'E') {
                return res * Math.pow(10, scanInt());
            }
            res *= 10;
            res += c - '0';
            c = scan();
        }
        if (c == '.') {
            c = scan();
            double m = 1;
            while (!isWhiteSpace(c)) {
                if (c == 'e' || c == 'E') {
                    return res * Math.pow(10, scanInt());
                }
                m /= 10;
                res += (c - '0') * m;
                c = scan();
            }
        }
        return res * sgn;
    }

}

Advantages :

  • Scans Input faster than BufferReader
  • Reduces Time Complexity
  • Flushes Buffer for every next input

Methods :

  • scanChar() - scan single character
  • scanInt() - scan Integer value
  • scanLong() - scan Long value
  • scanString() - scan String value
  • scanDouble() - scan Double value
  • scanInt(int[] array) - scans complete Array(Integer)
  • scanLong(long[] array) - scans complete Array(Long)

Usage :

  1. Copy the Given Code below your java code.
  2. Initialise Object for Given Class

ScanReader sc = new ScanReader(System.in); 3. Import necessary Classes :

import java.io.BufferedInputStream; import java.io.IOException; import java.io.InputStream; 4. Throw IOException from your main method to handle Exception 5. Use Provided Methods. 6. Enjoy

Example :

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
class Main{
    public static void main(String... as) throws IOException{
        ScanReader sc = new ScanReader(System.in);
        int a=sc.scanInt();
        System.out.println(a);
    }
}
class ScanReader....

If you want to read both strings and ints, a solution is to use two Scanners:

Scanner stringScanner = new Scanner(System.in);
Scanner intScanner = new Scanner(System.in);

intScanner.nextInt();
String s = stringScanner.nextLine(); // unaffected by previous nextInt()
System.out.println(s);

intScanner.close();
stringScanner.close();
public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int i = scan.nextInt();
        scan.nextLine();
        double d = scan.nextDouble();
        scan.nextLine();
        String s = scan.nextLine();

        System.out.println("String: " + s);
        System.out.println("Double: " + d);
        System.out.println("Int: " + i);
    }
upvote
  flag
If you use the nextLine() method immediately following the nextInt() method, recall that nextInt() reads integer tokens; because of this, the last newline character for that line of integer input is still queued in the input buffer and the next nextLine() will be reading the remainder of the integer line (which is empty). – Neeraj Gahlawat

sc.nextLine() is better as compared to parsing the input. Because performance wise it will be good.

My testing yeilded the same results as Prine, however I did think of a fairly simple workaround:

Using BufferedReader#nextLine(), where you would Scanner#readLine(), avoids this bug. You could even possibly write your own Scanner wrapper to override the Scanner readLine function with the BufferedReader nextLine function.

I guess I'm pretty late to the party..

As previously stated, calling input.nextLine() after getting your int value will solve your problem. The reason why your code didn't work was because there was nothing else to store from your input (where you inputted the int) into string1. I'll just shed a little more light to the entire topic.

Consider nextLine() as the odd one out among the nextFoo() methods in the Scanner class. Let's take a quick example.. Let's say we have two lines of code like the ones below:

int firstNumber = input.nextInt();
int secondNumber = input.nextInt();

If we input the value below (as a single line of input)

54 234

The value of our firstNumber and secondNumber variable become 54 and 234 respectively. The reason why this works this way is because a new line feed (i.e \n) IS NOT automatically generated when the nextInt() method takes in the values. It simply takes the "next int" and moves on. This is the same for the rest of the nextFoo() methods except nextLine().

nextLine() generates a new line feed immediately after taking a value; this is what @RohitJain means by saying the new line feed is "consumed".

Lastly, the next() method simply takes the nearest String without generating a new line; this makes this the preferential method for taking separate Strings within the same single line.

I hope this helps.. Merry coding!

Not the answer you're looking for? Browse other questions tagged or ask your own question.