Qual è la differenza tra i metodi next () e nextLine () della classe Scanner?

Qual è la differenza principale tra next()e nextLine()?
Il mio obiettivo principale è leggere tutto il testo utilizzando un file Scannerche può essere "connesso" a qualsiasi fonte (file per esempio).

Quale dovrei scegliere e perché?

Preferisco sempre leggere l'input usando nextLine()e poi analizzare la stringa.

L'uso next()restituirà solo ciò che viene prima del delimitatore (il valore predefinito è uno spazio bianco). nextLine()sposta automaticamente lo scanner verso il basso dopo aver restituito la riga corrente.

Uno strumento utile per analizzare i dati da nextLine()sarebbe str.split("\\s+").

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

Per ulteriori informazioni sulla classe Scanner o sulla classe String, fare riferimento ai seguenti collegamenti.

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

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

next()può leggere l'input solo fino allo spazio. Non può leggere due parole separate da uno spazio. Inoltre, next()posiziona il cursore sulla stessa riga dopo aver letto l'input.

nextLine()legge l'input includendo lo spazio tra le parole (cioè, legge fino alla fine della riga \n). Una volta letto l'input, nextLine()posiziona il cursore nella riga successiva.

Per leggere l'intera riga puoi usare nextLine().

Da JavaDoc:

• A Scannersuddivide il suo input in token utilizzando un pattern delimitatore, che per impostazione predefinita corrisponde agli spazi.
• next(): Trova e restituisce il successivo token completo da questo scanner.
• nextLine(): Fa avanzare lo scanner oltre la riga corrente e restituisce l'input che è stato ignorato.

Quindi in caso di "small example<eol>text" next()dovrebbe restituire "piccolo" e nextLine()dovrebbe restituire "piccolo esempio"

Quello che ho notato a parte next () scansiona solo fino allo spazio dove come nextLine () scansiona l'intera riga è che next aspetta finché non ottiene un token completo dove come nextLine () non aspetta il token completo, quando mai '\ n' si ottiene (cioè quando si preme il tasto Invio) il cursore dello scanner si sposta sulla riga successiva e restituisce la riga precedente saltata. Non controlla se hai fornito o meno un input completo, anche se prenderà una stringa vuota dove come next () non accetta una stringa vuota

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

}

Prova questo programma cambiando next () e nextLine () nel ciclo for, continua a premere '\ n' che è il tasto Invio senza alcun input, puoi scoprire che usando il metodo nextLine () termina dopo aver premuto un dato numero di casi in cui poiché next () non termina fino a quando non viene fornito e inserito per il numero di casi specificato.

Il punto chiave è trovare dove si fermerà il metodo e dove si troverà il cursore dopo aver chiamato i metodi.

Tutti i metodi leggeranno le informazioni che non includono spazi tra la posizione del cursore ei successivi delimitatori predefiniti (spazi, tabulazioni, \ n - creati premendo Invio). Il cursore si ferma prima dei delimitatori ad eccezione di nextLine(), che legge le informazioni (inclusi gli spazi bianchi creati dai delimitatori) tra la posizione del cursore e \ ne il cursore si ferma dietro \ n.

Ad esempio, considera la seguente illustrazione:

|23_24_25_26_27\n

| -> la posizione corrente del cursore

_ -> spazi bianchi

stream -> Bold (le informazioni ottenute dal metodo chiamante)

Guarda cosa succede quando chiami questi metodi:

nextInt()    

leggi 23 | _24_25_26_27 \ n

nextDouble()

leggi 23_ 24 | _25_26_27 \ n

next()

leggi 23_24_ 25 | _26_27 \ n

nextLine()

leggi 23_24_25 _26_27 \ n |

Successivamente, il metodo dovrebbe essere chiamato in base alle tue esigenze.

In breve: se stai inserendo un array di stringhe di lunghezza t, Scanner # nextLine () si aspetta t linee, ogni voce nell'array di stringhe è differenziata dall'altra con il tasto Invio e Scanner # next () continuerà a prendere input fino a premi Invio ma memorizza la stringa (parola) all'interno dell'array, che è separato da spazi bianchi.

Diamo un'occhiata al seguente frammento di codice

    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 eseguo lo snippet di codice nel mio IDE (diciamo per la lunghezza della stringa 2), non importa se inserisco la mia stringa come

Immettere come: - abcd abcd o

Immettere come: -

abcd

abcd

L'output sarà come abcd

abcd

Ma se nello stesso codice sostituiamo il metodo next () con 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();
    }

Quindi se inserisci l'input al prompt come - abcd abcd

L'output è: -

abcd abcd

e se inserisci l'input al prompt come abcd (e se premi invio per inserire il prossimo abcd in un'altra riga, il prompt di input uscirà e otterrai l'output)

L'output è: -

abcd

Da javadocs

next () Restituisce il token successivo se corrisponde al modello costruito dalla stringa specificata. nextLine () Fa avanzare lo scanner oltre la riga corrente e restituisce l'input che è stato ignorato.

Quale sceglierai dipende da quale si adatta meglio alle tue esigenze. Se fossi io a leggere un intero file, sceglierei nextLine finché non avessi tutto il file.

Dalla documentazione per Scanner :

Uno Scanner suddivide il suo input in token utilizzando un modello delimitatore, che per impostazione predefinita corrisponde agli spazi.

Dalla documentazione per next () :

Un token completo è preceduto e seguito da un input che corrisponde al modello delimitatore.

I metodi next () e nextLine () sono associati a Scanner e vengono utilizzati per ottenere input di stringa. Le loro differenze sono ...

next () può leggere l'input solo fino allo spazio. Non può leggere due parole separate da uno spazio. Inoltre, next () posiziona il cursore sulla stessa riga dopo aver letto l'input.

nextLine () legge l'input compreso lo spazio tra le parole (cioè, legge fino alla fine della riga \ n). Una volta letto l'input, nextLine () posiziona il cursore nella riga successiva.

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

Produzione:

inserisci la stringa per c abc def
c è abc

inserisci una stringa per d

d è def

Se usi nextLine () invece di next () allora

Produzione:

inserisci una stringa per c

ABC DEF
c è ABC DEF
immettere la stringa per d

GHI
d è GHI

• Solo per un altro esempio di Scanner.next () e nextLine () è come di seguito: nextLine () non consente all'utente di digitare mentre next () fa aspettare Scanner e leggere l'input.

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

Uno scanner suddivide il suo input in token utilizzando un pattern delimitatore, noto per impostazione predefinita come Whitespaces .

Next () usa per leggere una singola parola e quando ottiene uno spazio bianco, smette di leggere e il cursore torna alla sua posizione originale. NextLine () mentre questo legge una parola intera anche quando incontra uno spazio bianco. Il cursore si ferma quando ha finito di leggere e il cursore torna alla fine della riga. quindi non hai bisogno di usare un delimetro quando vuoi leggere una parola intera come frase. devi solo usare 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);
       }

Entrambe le funzioni vengono utilizzate per passare al gettone Scanner successivo.

La differenza sta nel modo in cui viene generato il token dello scanner

next () genera token scanner utilizzando delimitatore come spazio bianco

nextLine () genera i token dello scanner usando il delimitatore come '\ n' (cioè la pressione del tasto Invio)

Ho anche un problema relativo a un delimitatore. la domanda riguardava solo gli input di

1. Inserisci il tuo nome.
2. Inserisci la tua età.
3. Inserisci la tua email.
4. inserisci il tuo indirizzo.

Il problema

1. Ho terminato con successo con nome, età ed e-mail.
2. Quando ho trovato l'indirizzo di due parole con uno spazio bianco (Harnet street) ho appena ricevuto la prima "harnet".

La soluzione

Ho usato il delimitatore per il mio scanner e sono uscito con successo.

Esempio

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

La differenza fondamentale è next () viene utilizzata per ottenere l'input fino a quando non viene incontrato il delimitatore (di default è uno spazio bianco, ma puoi anche cambiarlo) e restituire il token che hai inserito.Il cursore rimane quindi sulla stessa riga. Mentre in nextLine () esegue la scansione dell'input fino a quando non premiamo il pulsante Invio e restituiamo l'intero file e posizioniamo il cursore nella riga successiva. **

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

**

Prova a eseguire questo codice dando Input come "Hello World". Lo scanner legge l'input fino a 'o' e quindi si verifica un delimitatore. Quindi s [0] sarà "Hello" e il cursore punterà alla posizione successiva dopo il delimitatore ( che è 'W' nel nostro caso), e quando s [1] viene letto, scansiona il "World" e lo restituisce a s [1] come il successivo token completo (per definizione di Scanner). Se usiamo nextLine () invece, leggerà "Hello World" completamente e anche di più finché non premiamo il pulsante Invio e lo memorizziamo in s [0]. Possiamo dare un'altra stringa anche usando nextLine (). Ti consiglio di provare a utilizzare questo e altro esempio e chiedere eventuali chiarimenti.