Início / coding / Perguntas / 79566621
Accepted
Ian
Asked: 2025-04-10 20:16:50 +0800 CST

Java - Excluindo entradas de console anteriores do System.in - Por que uma versão do meu código funciona e a outra não?

  • 772

A diferença no código está no método deleteInput(). Todo o resto é igual. A pergunta está no final, porque se trata da saída do console.

O código:

public class DeletePreviousInputs {
    static Scanner scanner = new Scanner(System.in);

    public static void main(String[] args) throws InterruptedException, IOException {
        System.out.println("write something in the console");
        /*
        * What I wrote:
        1 <enter> 2 <enter> 3 <enter> 4 <enter>
        */
        Thread.currentThread();
        Thread.sleep(8000); //simulates delay
        deleteInput();
        System.out.println("after input should be deleted");
        System.out.println(scanner.nextLine());
        System.out.println(scanner.nextLine());
        System.out.println(scanner.nextLine());
    }

    //Version 1 of the deleteInput()-Method:
    private static void deleteInput() throws InterruptedException {
        try {
            while (System.in.available() > 0) {
                //This is the part, where the code will differ in Version 2
                scanner.nextLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //Version 2 of the deleteInput()-Method:
    private static void deleteInput() throws InterruptedException {
        try {
            while (System.in.available() > 0) {
                //This is the part, where the code differs
                Scanner dummyScanner = new Scanner(System.in);
                dummyScanner.nextLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Versão de saída 1:

write something in the console
1
2
3
after input should be deleted
2
3

Versão de saída 2:

write something in the console
1
2
3
after input should be deleted

Por que a versão 1 não exclui/ignora todas as entradas anteriores? Por que a versão 2 funciona perfeitamente?

Tentei excluir todas as entradas anteriores de System.in para que apenas as mais recentes fossem reconhecidas pelo Scanner. Não esperava ver diferença na funcionalidade entre os dois métodos deleteInput(). Não entendo por que uma versão funciona e a outra não.

Atualizar:

@Sash (Não posso responder ao seu comentário por algum motivo, então atualizo aqui) Eu tentei e alterei apenas o método deleteInput() para isso:

System.out.println("deleteInput()-method has started");
while (scanner.hasNextLine()) {
    scanner.nextLine();
}
System.out.println("deleteInput()-method has ended");

Mas isso cria um loop e o método nunca é encerrado. Aqui está a saída que recebo:

write something in the console
1
2
3
deleteInput()-method has started

Se eu substituir scanner.nextLine() por:

if(scanner.nextLine().isEmpty()) {
    break;
}

ele também não sai do método.

java

2 respostas

  1. Scannermantém seu próprio buffer. Quando você chama nextLine, ele não lê necessariamente apenas uma linha. Ele tenta preencher seu buffer, lendo o máximo possível, e então retorna a primeira linha do buffer.

    Na versão 1, deleteInput, System.in.available() > 0é inicialmente verdadeiro, e o scanner lê tudo (todas as 4 linhas) em System.in, porque seu buffer é grande o suficiente. Na segunda iteração do loop, System.in.available() > 0seria falso, porque agora tudo está no buffer do scanner.

    Depois deleteInput(), você usa o mesmo scanner para ler as linhas. Como o buffer do scanner ainda contém algumas linhas, readLineretornará uma linha do buffer, em vez de ler o System.influxo subjacente.

    Na versão 2, você usa um scanner diferente em deleteInput, então o buffer de scannerpermanece vazio. Como resultado, o scanner.nextLine()after deleteInput()lerá de System.in.

    Como alternativa ao uso de um Scanner, você também pode fazer:

    System.in.readNBytes(System.in.available());

    Observe que nem a versão acima nem a sua versão 2 pularão coisas que scannerjá foram colocadas em seu buffer antes de você chamar deleteInput. Por exemplo,

    Thread.sleep(8000); // suppose the user enters multiple lines during this time
scanner.nextLine(); // this fills the scanner's buffer
deleteInput(); // this will only read anything if the input does not fit into the scanner's buffer
System.out.println(scanner.nextLine()); // if there is a line in the scanner's buffer, this will only read from the buffer, not from System.in
    • 4
  2. Best Answer

    Versão 1 dedeleteInput

    • scanner.nextLine()retorna uma linha, mas consome toda a entrada disponível
    • Portanto, o próximo System.out.println(scanner.nextLine())tem algo a imprimir,

    Nota adicional: System.in.available()retorna 0após uma única chamada para scanner.nextLine(), porque toda a entrada é consumida porscanner

    Versão 2 dedeleteInput

    • dummyScannerconsome toda a entrada disponível.
    • Por isso o original scanner.nextLine()não tem nada a ler
    • Portanto, System.out.println(scanner.nextLine())não produz nada

    Código para ilustrar esse comportamento:

    System.out.println("Input 3 lines");

Thread.currentThread();
Thread.sleep(8000);

System.out.println("After sleep");

Scanner scanner1 = new Scanner(System.in);
Scanner scanner2 = new Scanner(System.in);

System.out.println("scanner1.nextLine() - " + scanner1.nextLine());

if (System.in.available() > 0) {
    System.out.println("scanner2.nextLine() - " + scanner2.nextLine());
} else {
    System.out.println("No input available");
}

System.out.println("scanner1.nextLine() - " + scanner1.nextLine());
System.out.println("scanner1.nextLine() - " + scanner1.nextLine());

    Na entrada:

    1
2
3

    A saída é:

    After sleep
scanner1.nextLine() - 1
No input available
scanner1.nextLine() - 2
scanner1.nextLine() - 3
    • 1

relate perguntas