Máy quét đang bỏ qua nextLine () sau khi sử dụng next () hoặc nextFoo ()?

Tôi đang sử dụng các Scannerphương phápnextInt() và nextLine()để đọc đầu vào.

Nó trông như thế này:

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)

Vấn đề là sau khi nhập giá trị số, cái đầu tiên input.nextLine()bị bỏ qua và cái thứ hai input.nextLine()được thực thi, để đầu ra của tôi trông như thế này:

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

Tôi đã thử nghiệm ứng dụng của mình và có vẻ như vấn đề nằm ở việc sử dụng input.nextInt(). Nếu tôi xóa nó, thì cả hai string1 = input.nextLine()và string2 = input.nextLine()được thực thi như tôi muốn.

Đó là bởi vì Scanner.nextIntphương thức không đọc ký tự dòng mới trong đầu vào của bạn được tạo bằng cách nhấn "Enter" và do đó, lệnh gọi Scanner.nextLinetrả về sau khi đọc dòng mới đó .

Bạn sẽ gặp hành vi tương tự khi bạn sử dụng Scanner.nextLinesau Scanner.next()hoặc bất kỳ Scanner.nextFoophương thức nào (ngoại trừ nextLinechính nó).

Cách giải quyết:

• Hoặc thực hiện Scanner.nextLinecuộc gọi sau mỗi cuộc gọi Scanner.nextInthoặc Scanner.nextFoosử dụng phần còn lại của đường dây đó, kể cả đường dây mới

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

• Hoặc, thậm chí tốt hơn, đọc đầu vào thông qua Scanner.nextLinevà chuyển đổi đầu vào của bạn sang định dạng phù hợp bạn cần. Ví dụ: bạn có thể chuyển đổi sang một số nguyên bằng Integer.parseInt(String)phương thức.

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

Vấn đề là với phương thức input.nextInt () - nó chỉ đọc giá trị int. Vì vậy, khi bạn tiếp tục đọc với input.nextLine (), bạn sẽ nhận được phím Enter "\ n". Vì vậy, để bỏ qua điều này, bạn phải thêm input.nextLine () . Hy vọng điều này sẽ được rõ ràng bây giờ.

Hãy thử nó như thế:

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

Đó là bởi vì khi bạn nhập một số rồi bấm Enter, input.nextInt()chỉ tiêu thụ số đó, không phải là "cuối dòng". Khi input.nextLine()thực thi, nó sẽ tiêu thụ "cuối dòng" trong bộ đệm từ đầu vào đầu tiên.

Thay vào đó, sử dụng input.nextLine()ngay sau đóinput.nextInt()

Dường như có nhiều câu hỏi về vấn đề này với java.util.Scanner. Tôi nghĩ rằng một giải pháp dễ đọc / thành ngữ hơn sẽ là gọi scanner.skip("[\r\n]+")để bỏ bất kỳ ký tự dòng mới nào sau khi gọi nextInt().

EDIT: như @PatrickParker lưu ý bên dưới, điều này sẽ gây ra một vòng lặp vô hạn nếu người dùng nhập bất kỳ khoảng trắng nào sau số. Xem câu trả lời của họ để biết mẫu tốt hơn để sử dụng mà bỏ qua: https://stackoverflow.com/a/42471816/143585

Nó làm điều đó bởi vì input.nextInt();không nắm bắt được dòng mới. bạn có thể làm như những người khác đề xuất bằng cách thêm một input.nextLine();bên dưới.
Ngoài ra, bạn có thể thực hiện kiểu C # và phân tích nextLine thành một số nguyên như vậy:

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

Làm điều này cũng hoạt động tốt, và nó giúp bạn tiết kiệm một dòng mã.

TL; DR Sử dụng scanner.skip("\\R")trước mỗi scanner.newLine()cuộc gọi, được thực hiện sau:

• scanner.next()
• scanner.next*TYPE*() phương pháp.

Những điều bạn cần biết:

• văn bản đại diện cho một vài dòng cũng chứa các ký tự không in được giữa các dòng (chúng tôi gọi chúng là dấu phân cách dòng) như

  • lợi nhuận vận chuyển (CR - theo chuỗi ký tự đại diện là "\r")
  • nguồn cấp dữ liệu (LF - theo chuỗi ký tự đại diện là "\n")

• Khi bạn đang đọc dữ liệu từ bảng điều khiển, nó cho phép người dùng nhập phản hồi của anh ta và khi anh ta hoàn thành, anh ta cần phải xác nhận bằng cách nào đó . Để làm như vậy, người dùng được yêu cầu nhấn phím "enter" / "return" trên bàn phím.

  Điều quan trọng là khóa này bên cạnh việc đảm bảo đặt dữ liệu người dùng vào đầu vào tiêu chuẩn (được đại diện bởi System.innó được đọc bởi Scanner) cũng gửi các dấu tách dòng phụ thuộc HĐH (như cho Windows\r\n ) sau nó.

  Vì vậy, khi bạn hỏi người dùng về giá trị như thế nào age, và người dùng gõ 42 và nhấn enter, đầu vào tiêu chuẩn sẽ chứa "42\r\n".

Vấn đề

Scanner#nextInt(và các phương pháp khác ) không cho phép Máy quét sử dụng các dải phân cách này. Nó sẽ đọc chúng từ (làm thế nào khác Máy quét sẽ biết rằng không có nhiều chữ số từ người dùng đại diện cho giá trị hơn so với khoảng trắng?) Sẽ xóa chúng khỏi đầu vào tiêu chuẩn, nhưng nó cũng sẽ lưu trữ các dấu tách dòng đó bên trong . Điều chúng ta cần nhớ là tất cả các phương thức Scanner luôn được quét bắt đầu từ văn bản được lưu trong bộ nhớ cache. Scanner#nextTypeSystem.inage

Bây giờ Scanner#nextLine()chỉ cần thu thập và trả về tất cả các ký tự cho đến khi tìm thấy dấu phân cách dòng (hoặc cuối luồng). Nhưng vì các dấu tách dòng sau khi đọc số từ bảng điều khiển được tìm thấy ngay lập tức trong bộ đệm của Máy quét, nó trả về Chuỗi trống, có nghĩa là Máy quét không thể tìm thấy bất kỳ ký tự nào trước các dấu tách dòng đó (hoặc cuối luồng).
BTW nextLinecũng tiêu thụ những dải phân cách.

Giải pháp

Vì vậy, khi bạn muốn xin số và sau đó cho toàn bộ dòng trong khi tránh chuỗi trống đó là kết quả của nextLine, một trong hai

• tiêu thụ phân tách dòng còn lại nextInttừ bộ đệm Bộ quét
  • gọi nextLine,
  • hoặc IMO cách dễ đọc hơn sẽ bằng cách gọi skip("\\R")hoặc skip("\r\n|\r|\n")để Máy quét bỏ qua phần khớp với dấu phân cách dòng (thông tin thêm về \R: https://stackoverflow.com/a/31060125 )
• không sử dụng nextInt(cũng không next, hoặc bất kỳ nextTYPEphương pháp nào ). Thay vào đó, hãy đọc toàn bộ dữ liệu từng dòng bằng cách sử dụng nextLinevà phân tích số từ mỗi dòng (giả sử một dòng chỉ chứa một số) thành loại thích hợp như intthông qua Integer.parseInt.

BTW : các phương thức có thể bỏ qua các dấu phân cách (theo mặc định tất cả các khoảng trắng như tab, dấu phân cách dòng) bao gồm cả các bộ nhớ cache của máy quét, cho đến khi chúng sẽ tìm thấy giá trị không phân cách tiếp theo (mã thông báo). Nhờ đó cho đầu vào như mãScanner#nextType"42\r\n\r\n321\r\n\r\n\r\nfoobar"

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

sẽ có thể chỉ định đúng num1=42 num2=321 name=foobar.

Thay vì input.nextLine()sử dụng input.next(), điều đó sẽ giải quyết vấn đề.

Mã sửa đổi:

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

Nếu bạn muốn đọc cả chuỗi và int, một giải pháp là sử dụng hai Trình quét:

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

Nếu bạn muốn quét đầu vào nhanh mà không bị nhầm lẫn vào phương thức lớp Scanner nextLine (), hãy sử dụng Trình quét đầu vào tùy chỉnh cho nó.

Mã số:

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

}

Ưu điểm:

• Quét đầu vào nhanh hơn BufferReader
• Giảm độ phức tạp thời gian
• Flushes Buffer cho mọi đầu vào tiếp theo

Phương pháp:

• scanChar () - quét một ký tự
• scanInt () - quét giá trị Số nguyên
• scanLong () - quét Giá trị dài
• scanString () - quét giá trị Chuỗi
• scanDouble () - quét Giá trị kép
• scanInt (int [] mảng) - quét toàn bộ mảng (Integer)
• scanLong (dài [] mảng) - quét toàn bộ mảng (Dài)

Sử dụng :

1. Sao chép mã đã cho bên dưới mã java của bạn.
2. Đối tượng khởi tạo cho lớp đã cho

ScanReader sc = new ScanReader(System.in); 3. Nhập các lớp cần thiết:

import java.io.BufferedInputStream; import java.io.IOException; import java.io.InputStream; 4. Ném IOException từ phương thức chính của bạn để xử lý Ngoại lệ 5. Sử dụng các Phương thức được cung cấp. 6. Thưởng thức

Thí dụ :

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

Để tránh sự cố, sử dụng nextLine();ngay sau nextInt();đó vì nó giúp xóa bộ đệm. Khi bạn bấm ENTERcác nextInt();không nắm bắt được dòng mới và do đó, bỏ qua các Scannermã sau đó.

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

sc.nextLine()là tốt hơn so với phân tích cú pháp đầu vào. Bởi vì hiệu suất khôn ngoan nó sẽ tốt.

Tôi đoán là tôi đến bữa tiệc khá muộn ..

Như đã nói trước đây, gọi input.nextLine()sau khi nhận được giá trị int của bạn sẽ giải quyết vấn đề của bạn. Lý do tại sao mã của bạn không hoạt động là vì không có gì khác để lưu trữ từ đầu vào của bạn (nơi bạn nhập int) vào string1. Tôi sẽ chỉ làm sáng tỏ hơn một chút cho toàn bộ chủ đề.

Hãy xem nextLine () là một số lẻ trong số các phương thức nextFoo () trong lớp Scanner. Hãy lấy một ví dụ nhanh .. Giả sử chúng ta có hai dòng mã giống như các dòng dưới đây:

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

Nếu chúng ta nhập giá trị bên dưới (dưới dạng một dòng đầu vào)

54 234

Giá trị của biến firstNumbervà secondNumberbiến của chúng tôi lần lượt là 54 và 234. Lý do tại sao cách này hoạt động theo cách này là vì nguồn cấp dữ liệu dòng mới ( tức là \ n ) KHÔNG được tạo tự động khi phương thức nextInt () nhận các giá trị. Nó chỉ đơn giản là lấy "int int" và tiếp tục. Điều này giống với phần còn lại của các phương thức nextFoo () ngoại trừ nextLine ().

nextLine () tạo nguồn cấp dữ liệu mới ngay lập tức sau khi lấy giá trị; đây là ý nghĩa của @RohitJain khi nói nguồn cấp dữ liệu mới là "tiêu thụ".

Cuối cùng, phương thức next () chỉ cần lấy Chuỗi gần nhất mà không tạo ra một dòng mới; điều này làm cho đây là phương pháp ưu tiên để lấy các Chuỗi riêng biệt trong cùng một dòng.

Tôi hy vọng điều này sẽ giúp .. Mã hóa vui vẻ!

Sử dụng 2 đối tượng máy quét thay vì một

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

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

nếu tôi mong đợi một đầu vào không trống

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

được sử dụng trong ví dụ trên:

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

Trong một trong những usecase của tôi, tôi đã có kịch bản đọc một giá trị chuỗi đứng trước một vài giá trị nguyên . Tôi đã phải sử dụng " vòng lặp for / while " để đọc các giá trị. Và không có gợi ý nào ở trên hoạt động trong trường hợp này.

Sử dụng input.next()thay vì input.nextLine()khắc phục vấn đề. Hy vọng điều này có thể hữu ích cho những người đối phó với kịch bản tương tự.

Sử dụng mã này nó sẽ khắc phục vấn đề của bạn.

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)

Như nextXXX()các phương pháp không đọc newline, ngoại trừ nextLine(). Chúng ta có thể bỏ qua newlinesau khi đọc bất kỳ non-stringgiá trị nào ( inttrong trường hợp này) bằng cách sử dụng scanner.skip()như dưới đây:

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

Tại sao không sử dụng Máy quét mới cho mỗi lần đọc? Giống như dưới đây. Với phương pháp này, bạn sẽ không phải đối mặt với vấn đề của mình.

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