对于java初学者来说，这是一个非常基本的问题。我在开始java（自学）时也遇到过同样的问题。实际上，当我们获取整数数据类型的输入时，它只读取整数值并留下换行符（\n），而这一行（即，通过整数动态输入离开新行）会在我们尝试获取新输入时产生问题。例如，如果我们接受整数输入，然后尝试接受字符串输入。

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

value2将自动读取换行符，不会接受用户输入。

解决方案：只需在进行下一个用户输入之前添加一行代码，即。

sc.nextLine();

或

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

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

问题在于输入。nextInt（）方法-它只读取int值。所以当你继续阅读输入时。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();

为什么每次读取时不使用新的扫描仪？如下所示。使用这种方法，您将不会面临您的问题。

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

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)

要解决此问题，只需进行扫描。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);
}

}

使用此代码将修复您的问题。

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)

由于nextXXX()方法不读取newline，nextLine()除外。我们可以在读取任何non-string值（本例中为int）后跳过newline，方法如下：

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

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

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

为避免此问题，请在nextInt();之后立即使用nextLine();，因为它有助于清除缓冲区。按下ENTER时，nextInt();不会捕获新行，因此稍后跳过Scanner代码。

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

如果您想快速扫描输入，而不会混淆扫描仪类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（）-扫描字符串值
• scanDouble（）-扫描双精度值
• scanInt（int[]数组）-扫描完整数组（整数）
• scanLong（long[]数组）-扫描整个数组（long）

用法：

1.将给定代码复制到java代码下面。
1.初始化给定类的对象
ScanReader sc = new ScanReader(System.in); 3.导入必要的类：
import java.io.BufferedInputStream; import java.io.IOException; import 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....

与解析输入相比，sc.nextLine()更好。因为在性能方面，这将是好的。

我想我参加晚会已经晚了。。
如前所述，在获取int值后调用input.nextLine()将解决问题。代码不起作用的原因是，从输入（输入int的地方）到string1中没有其他存储。我只想对整个主题再解释一下。
将*nextLine（）视为Scanner类中nextFoo（）方法中的奇数。让我们举一个简单的例子。假设我们有两行代码，如下所示：

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

如果我们输入以下值（作为一行输入）：
54 234
firstNumber和secondNumber变量的值分别变为54和234。之所以如此，是因为当nextInt（）方法接受值时，不会自动生成换行符（即\n）。它简单地接受“next int”*，然后继续前进。这对于除nextLine（）之外的其他nextFoo（）方法也是一样的。
nextLine（）在获取值后立即生成新行换行符；这就是@RohitJain所说的新行馈送被“消耗”的意思。
最后，next（）方法只取最近的字符串，而**不生成新行；这使得它成为在同一行中获取单独字符串的首选方法。
我希望这有助于……快乐编码！

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

• 如果我期望一个非空输入*

避免：
–如果以下输入被未经检查的scan.nextLine()吃掉，则数据丢失
–由于scan.nextLine()被scan.next()替换，仅部分读取行导致数据丢失*（输入：“yippie ya yeah”）*
–使用Scanner方法解析输入时抛出的E1D3D1E*（先读取，后解析）*

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

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

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