使用Next（）或NextFoo（）之后，Scanner跳过NextLine（）？

Question

我正在使用 scanner 方法 nextInt（）和 nextline（）用于阅读输入。

看起来这样：

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)

问题是，在输入数值后，跳过了第一个 input.nextline（），第二个 input.nextline（）被执行，所以我的输出看起来像这样：

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

我测试了我的应用程序，看起来问题在于使用 input.nextint（）。如果我删除它，则两个 string1 = input.nextline（） and string2 = input.nextline（）按照我希望的方式执行。

Answer 1

那是因为 scanner.nextint 方法在您创建的输入中未读取 newline 字符，通过击中“ Enter”创建的输入，因此调用 scanner.nextline < /code> 阅读该 newline 后返回。

当您使用 scanner.nextline 之后，您将遇到类似的行为/java/util/scanner.html#next（）“ rel =“ noreferrer”> scanner.next（） 或任何 scanner.nexner.nextfoo method（除外 NextLine 本身）。

解决方法：

• 要么将 scanner.nextline 在每个 scanner.nextint 或 scanner.nextfoo 之后呼叫消耗该行的其余部分，包括 newline ：

    int option = input.nextint（）;
   input.nextline（）; //消费在newline上
   字符串str1 = input.nextline（）;
   

• 或更好的是，通过 scanner.nextline 读取输入，然后将您的输入转换为所需的正确格式。例如，您可以使用 integer.parseint（string） 方法：

    int option = 0;
   尝试 {
       option = integer.parseint（input.nextline（））;
   } catch（numberFormateXception e）{
       e.printstacktrace（）;
   }
   字符串str1 = input.nextline（）;
   

Answer 2

问题在于 input.nextint（）方法；它只读取int值。因此，当您继续使用 input.nextline（）继续阅读时，您会收到“ \ n” Enter键。因此，要跳过此功能，您必须添加 input.nextline（）。

这样尝试，而是：

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();

Answer 3

这是因为当您输入一个数字时，请按 Enter ， input.nextint（）仅消耗数字，而不是“行的结尾”。当 input.nextline（）执行时，它会消耗第一个输入从缓冲区中仍在缓冲区中的“末端”。

而是在 input> input.nextint（）之后立即使用 input.nextline（）

Answer 4

java.util.scanner 似乎有很多问题。我认为一个更可读/惯用的解决方案将是调用 scanner.skip（“ [\ r \ n]+”）在调用 nextint（）之后删除任何newline字符 。

编辑：正如@patrickparker下面指出的那样，如果用户输入数字之后的任何空格，这将导致无限循环。请参阅他们的答案，以获取与SKIP一起使用的更好模式： https：//stackoverflow.com/a/a/42471816/143585

Answer 5

tl; dr
nextline（）是（a）是（a）首先阅读指令，（b）先前的读取指令也是 nextline（）。

如果您不确定以上两个是正确的，则可以使用 scanner.skip（“ \\ r？”）在调用 scanner.nextline（）之前代码> next（） nextint（）将留下潜在的行分隔符 - 由 return return 键创建，这将影响 nextline（）。 .skip（“ \\ r？”）会让我们消耗此不必要的行分隔符。

skip 使用REGEX其中

• \ r 表示行分隔符
• ？将制造 \ r 可选 - 哪个将阻止跳过从：
  • 等待匹配序列
    • 如果到达仍打开数据源的末端，例如 system.in ，插座的输入流等等。
  • 投掷 java.util.nosuchelementException 在
    • 数据的终止/封闭源
    • 或现有数据不匹配我们要跳过的内容

您需要知道的内容时：

• 文本代表很少的行还包含行之间的不可打印字符（我们称它们为行分隔符）

• carriagare返回（cr-在字符串文字中表示为 “ \ r” ）

  


• line feed（lf-在字符串文字中表示为 “ \ n” ）

  


• 当您从控制台读取数据时，它允许用户键入他的响应，完成后，他需要以某种方式确认这一事实。为此，要求用户按键盘上的“ Enter”/“ return”键。

  
  

重要的是，该密钥在确保将用户数据放置到标准输入（由 System.in 表示）也发送OS依赖行分隔符（例如Windows \ r \ n ）。

因此，当您向用户询问 age 的值时，用户类型42并按ENTER，标准输入将包含“ 42 \ r \ n” 。

问题

扫描仪＃nextint （和其他 scanner＃next type 方法）不允许扫描仪到消耗这些线分隔符。它将从 system.in 读取它们（否则扫描仪如何知道，用户不再有代表 age 值的数字，而不是面对whitespace？）哪个会删除它们从标准输入中，但也将 CACHE 内部分离器。我们需要记住的是，所有扫描仪方法总是从缓存的文本开始扫描。

现在扫描仪＃nextline（）只需收集并返回所有字符，直到它找到行分隔符（或流的结尾）。但是，由于在读取控制台的数字后立即在扫描仪的高速缓存中找到了线分离器，因此它返回空字符串，这意味着扫描仪无法在这些行分隔符（或流的结尾）之前找到任何字符。

btw nextline 也消耗那些行分隔符。

解决方案

因此，当您要索要数字，然后在整个行中索要数字时，同时避免了 NextLine 的结果，要么

• NextInt 将行分隔机从扫描仪缓存中消耗。
• 通过调用 nextline ，
• 或IMO 更可读 的方法是通过调用 skip（“ \\ r”）>或 skip（“ \ r \ n | \ r | \ n”）让Scanner Skip skip part由行分隔符匹配（更多有关 \ r ： https://stackoverflow.com/a/31060125 ）
• 不使用 next> nextint （nor next> next ，next ，或任何 nextType 方法）。而是使用 NextLine 逐行阅读整个数据，并从每行分析数字（假设一行仅包含一个数字）到适当的类型，例如 int via integer .parseint 。

---

btw ： scanner＃next type 方法可以 skip deleimiters（默认情况下，所有空间像标签一样，行分隔符），包括扫描仪缓存的符号，直到他们找到下一个非核子值（令牌）为止。感谢此输入，例如“ 42 \ r \ n \ r \ r \ n321 \ r \ r \ n \ r \ r \ n \ n \ r \ nfoobar” 代码

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

将能够正确分配 num1 = 42 = 42 < /code> num2 = 321 name = foobar 。

Answer 6

之所以这样做，是因为 input.nextint（）; 不会捕获新线。您可以像通过在下面添加 input.nextline（）; 。
另外，您可以做到C＃样式，并将隔壁分析到这样的整数：

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

也这样做也可以为您节省一系列代码。

Answer 7

代替 input.nextline（）使用 input.next（），应该解决问题。

修改的代码：

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();
}

Answer 8

如果您想同时阅读字符串和INT，则解决方案是使用两个扫描仪：

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();

Answer 9

为了避免问题，请在 nextline（）; 之后使用 nextint（）; 之后，因为它有助于清除缓冲区。当您按输入 nextInt（）; 不会捕获新行，因此请稍后跳过 scanner 代码。

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

Answer 10

如果您想快速扫描输入而不会混淆扫描仪类NextLine（）方法，请使用自定义输入扫描仪。

代码：

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;
    }

}

优点：

• 扫描输入比BufferReader更快地
• 降低时间复杂度
• 为每个下一个输入方法冲洗缓冲区

：

• scanchar（） - 扫描单个字符
• scanint（） - 扫描整数值
• scanlong（） - 扫描长度
• 值scanstring
• （） ） - 扫描双值
• 扫描（int []数组） - 扫描完成数组（整数）
• 扫描（long [] array） - 扫描完成数组（长）

用法：

1. 在您的Java代码下方复制给定代码。
2. 给定类的初始对象

scanReader sc = new ScanReader（System.in）;

3。导入必要的类：

导入java.io.bufferedinputstream;
导入java.io.ioexception;
导入java.io.inputstream;

4。从您的主要方法中抛出ioException以处理异常
5。使用提供的方法。
6。享受

示例：

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....

Answer 11

sc.nextline（）与解析输入相比更好。
因为性能明智，这将是好的。

Answer 12

我想我参加聚会很晚了

。您的代码不起作用的原因是，从输入（输入INT输入）中没有其他可存储在 String1 中。我将为整个主题提供更多的启示。

考虑 nextline（）作为扫描仪类中 nextfoo（）方法中的奇数。让我们快速举个例子。假设我们有两行代码，如下：

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

如果我们输入以下值（作为单个输入行）

54 234

我们的 firstNumber 和 secondnumber 变量的值分别为54和234。这样做的原因是因为新的线feed（ ie \ n ） 不是 在NextInt（）方法采用时会自动生成在值中。它只是采用“下一个int” 并继续前进。对于NextLine（）除外的其余方法，其余的方法是相同的。

nextline（）在获得值后立即生成新的线供稿；这就是@RoHitjain的意思，说新的线供稿被“消耗”。

最后，Next（）方法仅采用最近的字符串而无需生成新线路；这使得这是在同一单线内采用单独字符串的优先方法。

我希望这会有所帮助..快乐的编码！

Answer 13

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);
    }

Answer 14

在我的一个用途酶中，我的场景是读取字符串值之前的几个整数值。我必须使用“ for / wher loop < / strong>”来读取值。在这种情况下，以上建议均无效。

使用 input.next（）而不是 input.nextline（）修复了问题。希望这对处理类似情况的人可能会有所帮助。

Answer 15

如果我期望非空输入

避免：
- ＆nbsp;如果未选中的 scan.nextline（）作为解决方案，则数据丢失如果以下输入
- ＆nbsp;由于 scan.nextline（）仅由部分读取行引起的数据丢失被 scan.next（） （输入：“ yippie＆nbsp; ya＆nbsp; yeah yeai ）
- ＆nbsp; scanner methods 的分析输入时抛出

public static Function<Scanner,String> scanLine = (scan -> {
    String s = scan.nextLine();
    return( s.length() == 0 ? scan.nextLine() : s );
  });

异常 s在使用

System.out.println("Enter numerical value");    
int option = input.nextInt(); // read numerical value from input

System.out.println("Enter 1st string"); 
String string1 = scanLine.apply( input ); // read 1st string
System.out.println("Enter 2nd string");
String string2 = scanLine.apply( input ); // read 2nd string

Answer 16

使用2个扫描仪对象而不是一个

Scanner input = new Scanner(System.in);
System.out.println("Enter numerical value");    
int option;
Scanner input2 = new Scanner(System.in);
option = input2.nextInt();

Answer 17

AS nextxxx（）方法不读取 newline ， nextline（）。我们可以使用 scanner.skip（）<读取任何 newline newline nor value value（ int ）< /代码>如下：

Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
sc.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
System.out.println(x);
double y = sc.nextDouble();
sc.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
System.out.println(y);
char z = sc.next().charAt(0);
sc.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
System.out.println(z);
String hello = sc.nextLine();
System.out.println(hello);
float tt = sc.nextFloat();
sc.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
System.out.println(tt);

Answer 18

使用此代码将解决您的问题。

System.out.println("Enter numerical value");    
int option;
option = input.nextInt(); // Read numerical value from input
input.nextLine();
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)

Answer 19

要解决此问题，只需使 scan.nextline（），其中 scan 是扫描仪对象的一个​​实例。例如，我正在使用一个简单的hackerrank问题进行解释。

package com.company;
import java.util.Scanner;

public class hackerrank {
public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    int i = scan.nextInt();
    double d = scan.nextDouble();
    scan.nextLine(); // This line shall stop the skipping the nextLine() 
    String s = scan.nextLine();
    scan.close();



    // Write your code here.

    System.out.println("String: " + s);
    System.out.println("Double: " + d);
    System.out.println("Int: " + i);
}

}

Answer 20

nextline（）将直接读取为空行，而无需等待文本。

通过添加额外的扫描仪来消耗空线来简单解决方案：

System.out.println("Enter numerical value");    
int option;
option = input.nextInt(); // Read numerical value from input
input.nextLine();
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)

Answer 21

对于Java的初学者编码器来说，这是一个非常基本的问题。当我开始使用Java时，我也遇到了同样的问题（自学教学）。
实际上，当我们获取整数数据类型的输入时，它仅读取整数值并留下newline（\ n）字符，并且当我们尝试采用新输入时，此行（即通过整数动态输入借鉴了新线路）会产生问题。
例如。就像我们获取整数输入一样，然后在尝试获取字符串输入之后。

value1=sc.nextInt();
value2=sc.nextLine();

Value2将自动读取Newline字符，并且不会获取用户输入。

解决方案：
只是我们需要添加一行代码，然后再进行下一个用户输入IE

sc.nextLine();

或

value1=sc.nextInt();
sc.nextLine();
value2=sc.nextLine();

注意：不要忘记关闭扫描仪以防止内存泄漏；

Answer 22

问题是input.nextint（）方法 - 它仅读取int值。因此，当您继续使用input.nextline（）继续阅读时，您会收到“ \ n”输入密钥。因此，要跳过此功能，您必须添加input.nextline（）。希望这应该很清楚。

这样尝试：

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();

Answer 23

 Scanner scan = new Scanner(System.in);
 int i = scan.nextInt();
 scan.nextLine(); // to Ignore the rest of the line after  (integer input)nextInt()
 double d=scan.nextDouble();
 scan.nextLine();
 String s=scan.nextLine();
 scan.close();
 System.out.println("String: " + s);
 System.out.println("Double: " + d);
 System.out.println("Int: " + i);

Answer 24

使用BufferedReader类用于输入字符串，这不会创建问题

Answer 25

为什么不为每次阅读使用新的扫描仪？如下。通过这种方法，您不会面对您的问题。

int i = new Scanner(System.in).nextInt();