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

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

博士TL; 当(a)它是第一个读取指令，(b)之前的读取指令也是nextLine()时，调用nextLine()是安全的。

如果你不确定以上任何一个是正确的，你可以在调用scanner.nextLine()之前使用scanner.skip("\\R?")，因为调用next() nextInt()将留下潜在的行分隔符-由返回键创建，这将影响nextLine()的结果。.skip("\\R?")将让我们使用这个不必要的行分隔符。

Skip使用正则表达式where

\R表示行分隔符 ？ 将使\R是可选的-这将防止跳过方法: 等待匹配序列 在系统等仍然开放的数据源到达终点时。在，输入流从套接字等。 抛出java.util.NoSuchElementException 终止/关闭的数据来源， 或者当现有数据与我们想要跳过的内容不匹配时

你需要知道的事情:

表示几行的文本在行之间也包含不可打印的字符(我们称之为行分隔符) 回车(CR -在字符串中以“\r”表示) 换行(LF - in字符串字面值表示为“\n”) 当您从控制台读取数据时，它允许用户输入他的响应，当他完成时，他需要以某种方式确认这一事实。为此，用户需要按下键盘上的“enter”/“return”键。

重要的是，除了确保将用户数据放置到标准输入(由System。(由Scanner读取)还会在后面发送与操作系统相关的行分隔符(如Windows \r\n)。

因此，当您向用户询问年龄等值时，用户输入42并按enter，标准输入将包含“42\r\n”。

问题

Scanner#nextInt(以及其他Scanner#nextType方法)不允许Scanner使用这些行分隔符。它将从系统中读取它们。in(否则Scanner如何知道用户没有更多的数字表示年龄值而不是面对空白?)，这将从标准输入中删除它们，但它也将在内部缓存这些行分隔符。我们需要记住的是，所有的Scanner方法总是从缓存的文本开始扫描。

现在Scanner#nextLine()只是收集并返回所有字符，直到找到行分隔符(或流的结束)。但是由于从控制台读取数字后的行分隔符立即在Scanner的缓存中找到，因此它返回空String，这意味着Scanner无法在这些行分隔符(或流的结束)之前找到任何字符。 顺便说一句，nextLine也会使用这些行分隔符。

解决方案

当你想要求number，然后求整行同时避免作为nextLine结果的空字符串

consume line separator left by nextInt from Scanners cache by calling nextLine, or IMO more readable way would be by calling skip("\\R") or skip("\r\n|\r|\n") to let Scanner skip part matched by line separator (more info about \R: https://stackoverflow.com/a/31060125) 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.

顺便说一句:扫描器#nextType方法可以跳过分隔符(默认情况下所有空白，如制表符，行分隔符)，包括扫描器缓存的那些，直到它们找到下一个非分隔符值(令牌)。感谢它输入像“42\r\n\r\n321\r\n\r\n\r\nfoobar”代码

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

将能够正确地分配num1=42 num2=321 name=foobar。

那是因为扫描仪。nextInt方法不读取通过按“Enter”创建的输入中的换行符，因此调用Scanner。nextLine在读取换行符后返回。

当您使用Scanner时，您将遇到类似的行为。在Scanner.next()或任何Scanner之后的nextLine。nextFoo方法(除了nextLine本身)。

处理:

Either put a Scanner.nextLine call after each 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, 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 Integer.parseInt(String) method. int option = 0; try { option = Integer.parseInt(input.nextLine()); } catch (NumberFormatException e) { e.printStackTrace(); } String str1 = input.nextLine();

关于java.util.Scanner的这个问题似乎有很多问题。我认为一个更可读/惯用的解决方案是调用scanner.skip("[\r\n]+")在调用nextInt()后删除任何换行符。

编辑:正如下面提到的@PatrickParker，如果用户在数字后输入任何空白，这将导致无限循环。关于更好的skip模式，请参阅他们的回答:https://stackoverflow.com/a/42471816/143585

如果你想快速扫描输入而不混淆到扫描器类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() - scan整数值 scanLong() -扫描长值 scanString() -扫描字符串值 scanouble () - scan双值 scanInt(int[] array) -扫描完整的数组(整数) scanLong(long[] array) -扫描完整的array (long)

用法:

复制java代码下面的给定代码。 初始化给定类的对象

ScanReader sc = new ScanReader(System.in); 3.导入必要的类:

进口java.io.BufferedInputStream; 进口java.io.IOException; 进口java.io.InputStream; 4. 从主方法中抛出IOException来处理Exception 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....

这样做是因为input.nextInt();不捕获换行符。你可以像其他人一样通过添加input.nextLine();在下面。 或者你也可以用c#风格，把nextLine解析成一个整数，如下所示:

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

这样做效果很好，而且节省了一行代码。