Qual é a diferença entre os métodos next () e nextLine () da classe Scanner?

Qual é a principal diferença entre next()e nextLine()?
Meu objetivo principal é ler todo o texto usando um Scannerque pode estar "conectado" a qualquer fonte (arquivo por exemplo).

Qual devo escolher e por quê?

Eu sempre prefiro ler a entrada usando nextLine()e, em seguida, analisar a string.

Usar next()retornará apenas o que vem antes do delimitador (o padrão é espaço em branco). nextLine()move automaticamente o scanner para baixo após retornar a linha atual.

Uma ferramenta útil para analisar dados do nextLine()seria str.split("\\s+").

String data = scanner.nextLine();
String[] pieces = data.split("\\s+");
// Parse the pieces

Para obter mais informações sobre a classe Scanner ou a classe String, consulte os links a seguir.

Scanner: http://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html

String: http://docs.oracle.com/javase/7/docs/api/java/lang/String.html

next()pode ler a entrada apenas até o espaço. Não pode ler duas palavras separadas por um espaço. Além disso, next()coloca o cursor na mesma linha após ler a entrada.

nextLine()lê a entrada incluindo o espaço entre as palavras (ou seja, lê até o final da linha \n). Assim que a entrada for lida, nextLine()posiciona o cursor na próxima linha.

Para ler toda a linha, você pode usar nextLine().

Do JavaDoc:

• A Scannerdivide sua entrada em tokens usando um padrão de delimitador, que por padrão corresponde a espaços em branco.
• next(): Localiza e retorna o próximo token completo deste scanner.
• nextLine(): Avança este scanner além da linha atual e retorna a entrada que foi ignorada.

Portanto, no caso de "small example<eol>text" next()deve retornar "pequeno" e nextLine()deve retornar "pequeno exemplo"

O que notei além de next () verifica apenas até o espaço, enquanto nextLine () verifica a linha inteira é que o próximo aguarda até obter um token completo, enquanto nextLine () não espera pelo token completo, quando sempre é obtido (ou seja, quando você pressiona a tecla Enter), o cursor do scanner se move para a próxima linha e retorna a linha anterior pulada. Não verifica se você forneceu a entrada completa ou não, mesmo que receba uma string vazia onde como next () não leva uma string vazia

public class ScannerTest {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int cases = sc.nextInt();
        String []str = new String[cases];
        for(int i=0;i<cases;i++){
            str[i]=sc.next();
        }
     }

}

Tente este programa alterando o next () e nextLine () no loop for, continue pressionando '\ n' que é a tecla enter sem qualquer entrada, você pode descobrir que usando o método nextLine () ele termina após pressionar um determinado número de casos onde como next () não termina até que você forneça uma entrada para ele para um determinado número de casos.

O ponto principal é descobrir onde o método irá parar e onde o cursor estará após chamar os métodos.

Todos os métodos irão ler informações que não incluem espaços em branco entre a posição do cursor e os próximos delimitadores padrão (espaço em branco, tabulação, \ n - criado pressionando Enter). O cursor para antes dos delimitadores, exceto para nextLine(), que lê informações (incluindo espaços em branco criados por delimitadores) entre a posição do cursor e \ n, e o cursor para atrás de \ n.

Por exemplo, considere a seguinte ilustração:

|23_24_25_26_27\n

| -> a posição atual do cursor

_ -> espaço em branco

stream -> Negrito (as informações obtidas pelo método de chamada)

Veja o que acontece quando você chama esses métodos:

nextInt()    

ler 23 | _24_25_26_27 \ n

nextDouble()

leia 23_ 24 | _25_26_27 \ n

next()

ler 23_24_ 25 | _26_27 \ n

nextLine()

ler 23_24_25 _26_27 \ n |

Depois disso, o método deve ser chamado de acordo com sua necessidade.

Resumindo: se você está inserindo uma matriz de string de comprimento t, então Scanner # nextLine () espera t linhas, cada entrada na matriz de string é diferenciada da outra pela tecla enter. E Scanner # next () continuará recebendo entradas até você pressiona enter, mas armazena string (palavra) dentro da matriz, que é separada por um espaço em branco.

Vamos dar uma olhada no seguinte trecho de código

    Scanner in = new Scanner(System.in);
    int t = in.nextInt();
    String[] s = new String[t];

    for (int i = 0; i < t; i++) {
        s[i] = in.next();
    }

quando executo o trecho de código acima em meu IDE (digamos para comprimento de string 2), não importa se eu insiro minha string como

Insira como: - abcd abcd ou

Insira como: -

abcd

abcd

A saída será como abcd

abcd

Mas se no mesmo código substituirmos o método next () por nextLine ()

    Scanner in = new Scanner(System.in);
    int t = in.nextInt();
    String[] s = new String[t];

    for (int i = 0; i < t; i++) {
        s[i] = in.nextLine();
    }

Então, se você inserir a entrada no prompt como - abcd abcd

O resultado é: -

abcd abcd

e se você inserir a entrada no prompt como abcd (e se você pressionar enter para inserir o próximo abcd em outra linha, o prompt de entrada apenas sairá e você obterá a saída)

O resultado é: -

abcd

De Javadocs

next () Retorna o próximo token se ele corresponder ao padrão construído a partir da string especificada. nextLine () Avança este scanner além da linha atual e retorna a entrada que foi ignorada.

Qual você escolhe depende do que melhor atende às suas necessidades. Se eu estivesse lendo um arquivo inteiro, iria para a nextLine até ter todo o arquivo.

Da documentação do Scanner :

Um Scanner divide sua entrada em tokens usando um padrão delimitador, que por padrão corresponde a espaços em branco.

Da documentação para next () :

Um token completo é precedido e seguido por uma entrada que corresponde ao padrão do delimitador.

Os métodos next () e nextLine () são associados a Scanner e são usados ​​para obter entradas de String. Suas diferenças são ...

next () pode ler a entrada apenas até o espaço. Não pode ler duas palavras separadas por espaço. Além disso, next () coloca o cursor na mesma linha após ler a entrada.

nextLine () lê a entrada incluindo o espaço entre as palavras (isto é, lê até o final da linha \ n). Depois que a entrada é lida, nextLine () posiciona o cursor na próxima linha.

import java.util.Scanner;

public class temp
{
    public static void main(String arg[])
    {
        Scanner sc=new Scanner(System.in);
        System.out.println("enter string for c");
        String c=sc.next();
        System.out.println("c is "+c);
        System.out.println("enter string for d");
        String d=sc.next();
        System.out.println("d is "+d);
    }
}

Resultado:

insira string para c abc def
c é abc

insira a string para d

d é def

Se você usar nextLine () em vez de next (), então

Resultado:

insira string para c

ABC DEF
c é ABC DEF
inserir string para d

GHI
d é GHI

• Apenas para outro exemplo de Scanner.next () e nextLine () é o seguinte: nextLine () não permite que o usuário digite enquanto next () faz Scanner esperar e ler a entrada.

   Scanner sc = new Scanner(System.in);
  
   do {
      System.out.println("The values on dice are :");
      for(int i = 0; i < n; i++) {
          System.out.println(ran.nextInt(6) + 1);
      }
      System.out.println("Continue : yes or no");
   } while(sc.next().equals("yes"));
  // while(sc.nextLine().equals("yes"));
  

Um scanner divide sua entrada em tokens usando um padrão delimitador, que é conhecido por padrão como espaços em branco .

Next () usa para ler uma única palavra e quando recebe um espaço em branco, para de ler e o cursor volta à posição original. NextLine (), enquanto este lê uma palavra inteira, mesmo quando encontra um espaço em branco. O cursor para quando termina de ler e volta para o final da linha. então você não precisa usar um delimitador quando quiser ler uma palavra inteira como uma frase. você só precisa usar NextLine ().

 public static void main(String[] args) {
            // TODO code application logic here
           String str;
            Scanner input = new Scanner( System.in );
            str=input.nextLine();
            System.out.println(str);
       }

Ambas as funções são usadas para mover para o próximo token do Scanner.

A diferença está em como o token do scanner é gerado

next () gera tokens de scanner usando delimitador como espaço em branco

nextLine () gera tokens de scanner usando delimitador como '\ n' (ou seja, pressionamentos de tecla Enter)

Também tive um problema com um delimitador. a questão era sobre as entradas de

1. digite seu nome.
2. insira sua idade.
3. Digite seu e-mail.
4. insira seu endereço.

O problema

1. Terminei com sucesso com nome, idade e e-mail.
2. Quando descobri o endereço de duas palavras com um espaço em branco (rua Harnet), acabei de receber a primeira "harnet".

A solução

Usei o delimitador para meu scanner e saí com sucesso.

Exemplo

 public static void main (String args[]){
     //Initialize the Scanner this way so that it delimits input using a new line character.
    Scanner s = new Scanner(System.in).useDelimiter("\n");
    System.out.println("Enter Your Name: ");
    String name = s.next();
    System.out.println("Enter Your Age: ");
    int age = s.nextInt();
    System.out.println("Enter Your E-mail: ");
    String email = s.next();
    System.out.println("Enter Your Address: ");
    String address = s.next();

    System.out.println("Name: "+name);
    System.out.println("Age: "+age);
    System.out.println("E-mail: "+email);
    System.out.println("Address: "+address);
}

A diferença básica é next () é usado para obter a entrada até que o delimitador seja encontrado (Por padrão, é um espaço em branco, mas você também pode alterá-lo) e retornar o token que você inseriu. O cursor então permanece na mesma linha. Enquanto em nextLine (), ele verifica a entrada até que pressionamos o botão Enter e retornamos tudo e colocamos o cursor na próxima linha. **

        Scanner sc=new Scanner(System.in);
        String s[]=new String[2];
        for(int i=0;i<2;i++){
            s[i]=sc.next();
        }
        for(int j=0;j<2;j++)
        {
            System.out.println("The string at position "+j+ " is "+s[j]);
        }

**

Tente executar este código fornecendo Input como "Hello World". O scanner lê a entrada até 'o' e então ocorre um delimitador. Então s [0] será "Hello" e o cursor estará apontando para a próxima posição após o delimitador ( isto é 'W' no nosso caso), e quando s [1] é lido, ele verifica o "Mundo" e o retorna para s [1] como o próximo token completo (por definição de Scanner). Se usarmos nextLine () em vez disso, ele lerá "Hello World" por completo e também mais até que cliquemos no botão Enter e o armazenemos em s [0]. Podemos fornecer outra string usando nextLine (). Eu recomendo que você tente usar este exemplo e muito mais e peça qualquer esclarecimento.