java - ¿Cuál es la diferencia entre los métodos next() y nextLine() de la clase Scanner?

sc nextline()

Question

¿Cuál es la principal diferencia entre next() y nextLine() ?
Mi objetivo principal es leer todo el texto usando un Scanner que puede estar "conectado" a cualquier fuente (archivo, por ejemplo).

¿Cuál debería elegir y por qué?

Answer 1

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

next () Devuelve el siguiente token si coincide con el patrón construido a partir de la cadena especificada. nextLine () Avanza este escáner más allá de la línea actual y devuelve la entrada que se saltó.

El que elija depende del que mejor se adapte a sus necesidades. Si fuera yo leyendo un archivo completo, iría por nextLine hasta que tuviera todo el archivo.

Answer 2

De JavaDoc:

• Un Scanner divide su entrada en tokens usando un patrón de delimitador, que por defecto coincide con el espacio en blanco.
• next() : busca y devuelve el siguiente token completo de este escáner.
• nextLine() : avanza este escáner más allá de la línea actual y devuelve la entrada que se saltó.

Entonces, en caso de "small example<eol>text" next() debería devolver "small" y nextLine() debería devolver "small example"

Answer 3

De la documentación para http://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html :

Un escáner divide su entrada en tokens usando un patrón de delimitador, que por defecto coincide con el espacio en blanco.

De la documentación para el next() :

Un token completo va precedido y seguido de una entrada que coincide con el patrón del delimitador.

Answer 4

En resumen: si está ingresando una matriz de cadenas de longitud t, entonces Scanner # nextLine () espera t líneas, cada entrada en la matriz de cadenas se diferencia de la otra mediante la tecla enter. Y Scanner # next () seguirá tomando entradas hasta presiona enter pero almacena cadena (palabra) dentro de la matriz, que está separada por espacios en blanco.

Echemos un vistazo al siguiente fragmento 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();
    }

cuando ejecuto un fragmento de código en mi IDE (digamos para la longitud de cadena 2), no importa si ingreso mi cadena como

Entrada como: - abcd abcd o

Entrada como: -

a B C D

a B C D

La salida será como abcd

a B C D

Pero si en el mismo código reemplazamos el 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();
    }

Luego, si ingresas la entrada en el prompt as - abcd abcd

La salida es: -

abcd abcd

y si ingresa la entrada en el prompt como abcd (y si presiona enter para ingresar el siguiente abcd en otra línea, el prompt de entrada simplemente saldrá y obtendrá el resultado)

La salida es: -

a B C D

Answer 5

Lo que he notado aparte de los escaneos next () solo hasta el espacio donde nextLine () escanea toda la línea es que el próximo espera hasta que obtenga un token completo donde nextLine () no espera el token completo, cuando ''/ n'' se obtiene (es decir, cuando presiona la tecla Entrar) el cursor del escáner se mueve a la siguiente línea y devuelve la línea anterior omitida. No verifica si ha dado una entrada completa o no, incluso tomará una cadena vacía donde el siguiente () no toma la cadena vacía

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

}

Pruebe este programa cambiando el siguiente () y nextLine () in para loop, siga presionando ''/ n'' que es la tecla enter sin ninguna entrada, puede encontrar que usando el método nextLine () termina después de presionar el número dado de casos donde como next () no termina hasta que lo proporcione y lo ingrese para el número de casos dado.

Answer 6

Los métodos next () y nextLine () están asociados con Scanner y se utilizan para obtener entradas de String. Sus diferencias son ...

next () puede leer la entrada solo hasta el espacio. No puede leer dos palabras separadas por espacio. Además, next () coloca el cursor en la misma línea después de leer la entrada.

nextLine () lee la entrada, incluido el espacio entre las palabras (es decir, lee hasta el final de la línea / n). Una vez que se lee la entrada, nextLine () posiciona el cursor en la siguiente línea.

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

Salida:

ingrese la secuencia para c abc def
c es abc

ingrese la cadena para d

d es def

Si usa nextLine () en lugar de next (), entonces

Salida:

ingrese la cadena para c

A B C D E F
c es ABC DEF
ingrese la cadena para d

GHI
d es GHI

Answer 7

Para esta pregunta, el punto clave es encontrar dónde se detendrá el método y dónde está el cursor después de llamar a los métodos. Todos los métodos leerán información (no incluye espacios en blanco) entre la posición del cursor y los siguientes delimitadores predeterminados (espacio en blanco, pestaña, / n - creado al presionar Enter) y el cursor se detiene antes de los delimitadores, excepto para nextLine (), que lee información (incluidos espacios en blanco creados por delimitadores) entre la posición del cursor y / n y el cursor se detiene detrás / n.

Por ejemplo: (| representa la posición actual del cursor; _ representa el espacio en blanco; transmite en negrita la información obtenida por el método de llamada)

23_24_25_26_27 / n

Llamar a nextInt (); leer 23 | _24_25_26_27 / n

Llamar a nextDouble (); leer 23_ 24 | _25_26_27 / n

Llamar al siguiente (); leer 23_24_ 25 | _26_27 / n

Llamar a NextLine (); lea 23_24_25 _26_27 / n |

Después de esto, se debe llamar al método dependiendo de su requerimiento.

Answer 8

Siempre prefiero leer la entrada usando nextLine() y luego analizar la cadena.

Usar next() solo devolverá lo que viene antes de un espacio. nextLine() mueve automáticamente el escáner hacia abajo después de devolver la línea actual.

Una herramienta útil para analizar datos de nextLine() sería str.split("//s+") .

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

Para obtener más información sobre la clase de escáner o la clase de cadena, consulte los siguientes enlaces.

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

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

Answer 9

También tengo un problema relacionado con un delimitador. la pregunta era todo acerca de las entradas de

1. introduzca su nombre.
2. introduzca su edad.
3. Introduce tu correo electrónico.
4. ingrese su dirección

El problema

1. Terminé exitosamente con nombre, edad y correo electrónico.
2. Cuando se me ocurrió la dirección de dos palabras que tienen un espacio en blanco (calle Harnet) acabo de obtener el primero "harnet".

La solución

Utilicé el delimitador para mi escáner y salí exitosamente.

Ejemplo

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

Answer 10

next() puede leer la entrada solo hasta el espacio. No puede leer dos palabras separadas por un espacio. Además, next() coloca el cursor en la misma línea después de leer la entrada.

nextLine() lee la entrada, incluido el espacio entre las palabras (es decir, lee hasta el final de la línea /n ). Una vez que se lee la entrada, nextLine() posiciona el cursor en la siguiente línea.

Para leer toda la línea, puede usar nextLine() .

Answer 11

Un escáner divide su entrada en tokens usando un patrón delimitador, que por defecto se conoce como Whitespaces .

Next () utiliza para leer una sola palabra y cuando obtiene un espacio en blanco, deja de leer y el cursor vuelve a su posición original. NextLine () mientras este lee una palabra completa incluso cuando se encuentra con un espacio en blanco. El cursor se detiene cuando termina de leer y el cursor retrocede hasta el final de la línea. por lo que no necesita usar un delímetro cuando quiera leer una palabra completa como una oración. Solo necesita 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);
       }

Answer 12

• Solo para otro ejemplo de Scanner.next () y nextLine () es el siguiente: nextLine () no permite que el usuario escriba mientras next () hace que Scanner espere y lea la 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"));