Quelle est la différence entre les méthodes next () et nextLine () de la classe Scanner?

Quelle est la principale différence entre next()et nextLine()?
Mon objectif principal est de lire tout le texte en utilisant un Scannerqui peut être "connecté" à n'importe quelle source (fichier par exemple).

Lequel dois-je choisir et pourquoi?

Je préfère toujours lire l'entrée en utilisant nextLine(), puis analyser la chaîne.

L'utilisation next()ne retournera que ce qui précède le délimiteur (par défaut un espace). nextLine()déplace automatiquement le scanner vers le bas après avoir renvoyé la ligne actuelle.

Un outil utile pour analyser les données à partir de nextLine()serait str.split("\\s+").

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

Pour plus d'informations sur la classe Scanner ou la classe String, reportez-vous aux liens suivants.

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

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

next()peut lire l'entrée seulement jusqu'à l'espace. Il ne peut pas lire deux mots séparés par un espace. Place également next()le curseur sur la même ligne après avoir lu l'entrée.

nextLine()lit l'entrée, y compris l'espace entre les mots (c'est-à-dire qu'il lit jusqu'à la fin de la ligne \n). Une fois l'entrée lue, nextLine()positionne le curseur sur la ligne suivante.

Pour lire la ligne entière, vous pouvez utiliser nextLine().

Depuis JavaDoc:

• A Scannerdivise son entrée en jetons à l'aide d'un modèle de délimiteur, qui par défaut correspond aux espaces.
• next(): Recherche et renvoie le prochain jeton complet de ce scanner.
• nextLine(): Fait avancer ce scanner au-delà de la ligne actuelle et renvoie l'entrée qui a été ignorée.

Donc en cas de "small example<eol>text" next()devrait retourner "petit" et nextLine()devrait renvoyer "petit exemple"

Ce que j'ai remarqué à part next () scanne seulement jusqu'à l'espace où comme nextLine () scanne toute la ligne, c'est que next attend jusqu'à ce qu'il obtienne un jeton complet où comme nextLine () n'attend pas le jeton complet, quand jamais '\ n' est obtenu (c'est-à-dire lorsque vous appuyez sur la touche Entrée), le curseur du scanner passe à la ligne suivante et renvoie la ligne précédente ignorée. Il ne vérifie pas si vous avez donné une entrée complète ou non, même il prendra une chaîne vide alors que next () ne prend pas de chaîne vide

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

}

Essayez ce programme en changeant le next () et nextLine () dans la boucle for, continuez en appuyant sur '\ n' qui est la touche d'entrée sans aucune entrée, vous pouvez trouver qu'en utilisant la méthode nextLine (), il se termine après avoir appuyé sur un nombre donné de cas où car next () ne se termine pas tant que vous ne l'avez pas fourni et saisi pour le nombre de cas donné.

Le point clé est de trouver où la méthode s'arrêtera et où se trouvera le curseur après avoir appelé les méthodes.

Toutes les méthodes liront les informations qui n'incluent pas les espaces entre la position du curseur et les prochains délimiteurs par défaut (espace, tabulation, \ n - créés en appuyant sur Entrée). Le curseur s'arrête avant les délimiteurs sauf pour nextLine(), qui lit les informations (y compris les espaces créés par les délimiteurs) entre la position du curseur et \ n, et le curseur s'arrête derrière \ n.

Par exemple, considérez l'illustration suivante:

|23_24_25_26_27\n

| -> la position actuelle du curseur

_ -> espace blanc

stream -> Bold (les informations obtenues par la méthode appelante)

Voyez ce qui se passe lorsque vous appelez ces méthodes:

nextInt()    

lire 23 | _24_25_26_27 \ n

nextDouble()

lire 23_ 24 | _25_26_27 \ n

next()

lire 23_24_ 25 | _26_27 \ n

nextLine()

lire 23_24_25 _26_27 \ n |

Après cela, la méthode doit être appelée en fonction de vos besoins.

En bref: si vous entrez un tableau de chaînes de longueur t, alors Scanner # nextLine () attend t lignes, chaque entrée dans le tableau de chaînes est différenciée de l'autre par la touche Entrée et Scanner # next () continuera à prendre des entrées jusqu'à vous appuyez sur Entrée mais stocke la chaîne (mot) dans le tableau, qui est séparé par des espaces.

Jetons un œil à l'extrait de code suivant

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

lorsque j'exécute au-dessus de l'extrait de code dans mon IDE (disons pour la longueur de chaîne 2), peu importe que j'entre ma chaîne comme

Entrez comme: - abcd abcd ou

Entrée comme: -

a B c d

a B c d

La sortie sera comme abcd

a B c d

Mais si dans le même code on remplace la méthode next () par 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();
    }

Ensuite, si vous entrez l'entrée à l'invite comme - abcd abcd

La sortie est: -

abcd abcd

et si vous entrez l'entrée à l'invite comme abcd (et si vous appuyez sur Entrée pour entrer le prochain abcd dans une autre ligne, l'invite d'entrée se fermera et vous obtiendrez la sortie)

La sortie est: -

a B c d

de javadocs

next () Renvoie le jeton suivant s'il correspond au modèle construit à partir de la chaîne spécifiée. nextLine () Avance ce scanner au-delà de la ligne actuelle et retourne l'entrée qui a été ignorée.

Celui que vous choisissez dépend de celui qui correspond le mieux à vos besoins. Si c'était moi en train de lire un fichier entier, je choisirais nextLine jusqu'à ce que j'aie tout le fichier.

À partir de la documentation du scanner :

Un scanner divise son entrée en jetons à l'aide d'un modèle de délimiteur, qui correspond par défaut aux espaces.

De la documentation pour next () :

Un jeton complet est précédé et suivi d'une entrée qui correspond au modèle de délimiteur.

Les méthodes next () et nextLine () sont associées à Scanner et sont utilisées pour obtenir des entrées String. Leurs différences sont ...

next () ne peut lire l'entrée que jusqu'à l'espace. Il ne peut pas lire deux mots séparés par un espace. De plus, next () place le curseur sur la même ligne après la lecture de l'entrée.

nextLine () lit l'entrée, y compris l'espace entre les mots (c'est-à-dire qu'il lit jusqu'à la fin de la ligne \ n). Une fois l'entrée lue, nextLine () positionne le curseur sur la ligne suivante.

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

Production:

entrez une chaîne pour c abc def
c est abc

entrez une chaîne pour d

d est def

Si vous utilisez nextLine () au lieu de next () alors

Production:

entrez une chaîne pour c

ABC DEF
c est ABC DEF
entrez une chaîne pour d

GHI
d est GHI

• Un autre exemple de Scanner.next () et nextLine () est celui ci-dessous: nextLine () ne permet pas à l'utilisateur de taper tandis que next () fait attendre Scanner et lire l'entrée.

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

Un analyseur divise son entrée en jetons à l'aide d'un modèle de délimiteur, qui est par défaut connu sous le nom de Whitespaces .

Next () utilise pour lire un seul mot et lorsqu'il reçoit un espace blanc, il arrête la lecture et le curseur revient à sa position d'origine. NextLine () alors que celui-ci lit un mot entier même s'il rencontre un espace blanc, le curseur s'arrête quand il a fini de lire et le curseur revient à la fin de la ligne. vous n'avez donc pas besoin d'utiliser un délimiteur lorsque vous voulez lire un mot complet sous forme de phrase. Il vous suffit d'utiliser 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);
       }

Les deux fonctions sont utilisées pour passer au jeton Scanner suivant.

La différence réside dans la manière dont le jeton du scanner est généré

next () génère des jetons de scanner en utilisant un délimiteur comme espace blanc

nextLine () génère des jetons de scanner en utilisant le délimiteur comme '\ n' (c'est-à-dire en appuyant sur la touche Entrée)

J'ai également eu un problème concernant un délimiteur. la question portait uniquement sur les contributions de

1. entrez votre nom.
2. Entrez votre âge.
3. entrer votre Email.
4. entrez votre adresse.

Le problème

1. J'ai terminé avec succès avec le nom, l'âge et l'e-mail.
2. Quand j'ai trouvé l'adresse de deux mots avec un espace (rue Harnet), je viens de recevoir le premier "harnet".

La solution

J'ai utilisé le délimiteur pour mon scanner et je suis sorti avec succès.

Exemple

 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 différence fondamentale est que next () est utilisé pour obtenir l'entrée jusqu'à ce que le délimiteur soit rencontré (par défaut, il s'agit d'un espace, mais vous pouvez également le modifier) ​​et renvoyer le jeton que vous avez entré.Le curseur reste alors sur la même ligne. Alors que dans nextLine (), il scanne l'entrée jusqu'à ce que nous appuyions sur le bouton Entrée et retournions le tout et place le curseur sur la ligne suivante. **

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

**

Essayez d'exécuter ce code en donnant Input comme "Hello World". Le scanner lit l'entrée jusqu'à ce que 'o' puis un délimiteur se produise. Ainsi, [0] sera "Hello" et le curseur pointera vers la position suivante après le délimiteur ( c'est-à-dire 'W' dans notre cas), et quand s [1] est lu, il scanne le "Monde" et le renvoie à s [1] comme le prochain jeton complet (par définition de Scanner). Si nous utilisons nextLine () au lieu de cela, il lira le "Hello World" complètement et aussi plus jusqu'à ce que nous appuyions sur le bouton Entrée et le stockions dans s [0]. Nous pouvons également donner une autre chaîne en utilisant nextLine (). Je vous recommande d'essayer d'utiliser cet exemple et plus encore et de demander des éclaircissements.