Java Language
Escáner

Sintaxis

• Escáner escáner = nuevo escáner (fuente de origen);
• Escáner escáner = nuevo escáner (System.in);

Parámetros

Observaciones

Lectura de la entrada del sistema utilizando el escáner

Scanner scanner = new Scanner(System.in); //Scanner obj to read System input
String inputTaken = new String();
while (true) {
    String input = scanner.nextLine(); // reading one line of input
    if (input.matches("\\s+"))         // if it matches spaces/tabs, stop reading
        break;
    inputTaken += input + " ";
}
System.out.println(inputTaken);

El objeto del escáner se inicializa para leer la entrada desde el teclado. Por lo tanto, para la siguiente entrada del teclado, producirá la salida como Reading from keyboard

Reading
from
keyboard
  //space

Lectura de entrada de archivo utilizando escáner

Scanner scanner = null;
try {
    scanner = new Scanner(new File("Names.txt"));
    while (scanner.hasNext()) {
        System.out.println(scanner.nextLine());
    }
} catch (Exception e) {
    System.err.println("Exception occurred!");
} finally {
    if (scanner != null)
        scanner.close();
}

Aquí se crea un objeto Scanner pasando un objeto File que contiene el nombre de un archivo de texto como entrada. Este archivo de texto se abrirá con el objeto Archivo y se leerá con el objeto del escáner en las siguientes líneas. scanner.hasNext() verificará si hay una próxima línea de datos en el archivo de texto. Combinar que con un while de bucle le permitirá iterar a través de cada línea de datos en el Names.txt archivo. Para recuperar los datos en sí, podemos usar métodos como nextLine() , nextInt() , nextBoolean() , etc. En el ejemplo anterior, se usa scanner.nextLine() . nextLine() hace referencia a la siguiente línea en un archivo de texto, y su combinación con un objeto de scanner permite imprimir el contenido de la línea. Para cerrar un objeto de escáner, usaría .close() .

Al usar try con recursos (desde Java 7 en adelante), el código mencionado anteriormente puede escribirse con elegancia de la siguiente manera.

try (Scanner scanner = new Scanner(new File("Names.txt"))) {
    while (scanner.hasNext()) {
        System.out.println(scanner.nextLine());
    }
} catch (Exception e) {
    System.err.println("Exception occurred!");
}

Lee toda la entrada como una cadena usando un escáner

Puede usar Scanner para leer todo el texto de la entrada como una Cadena, usando \Z (entrada completa) como delimitador. Por ejemplo, esto se puede usar para leer todo el texto en un archivo de texto en una línea:

String content = new Scanner(new File("filename")).useDelimiter("\\Z").next();
System.out.println(content);

Recuerde que tendrá que cerrar el Escáner, así como también capturar la IoException esto puede IoException , como se describe en el ejemplo Leyendo la entrada del archivo usando el Escáner .

Usando delimitadores personalizados

Puede usar delimitadores personalizados (expresiones regulares) con Scanner, con .useDelimiter(",") , para determinar cómo se lee la entrada. Esto funciona de manera similar a String.split(...) . Por ejemplo, puede usar el Scanner para leer de una lista de valores separados por comas en una cadena:

Scanner scanner = null;
try{
    scanner = new Scanner("i,like,unicorns").useDelimiter(",");;
    while(scanner.hasNext()){
        System.out.println(scanner.next());
    }
}catch(Exception e){
    e.printStackTrace();
}finally{
    if (scanner != null)
        scanner.close();
}

Esto le permitirá leer cada elemento en la entrada individualmente. Tenga en cuenta que no debe utilizar este para analizar los datos CSV, en cambio, utilizar una biblioteca adecuada analizador CSV, consulte CSV analizador para Java para otras posibilidades.

Patrón general que realiza las tareas más frecuentes.

Lo siguiente es cómo usar correctamente la clase java.util.Scanner para leer interactivamente la entrada del usuario de System.in correctamente (a veces se denomina stdin , especialmente en C, C ++ y otros idiomas, así como en Unix y Linux). Demuestra de manera idiomática las cosas más comunes que se requieren hacer.

package com.stackoverflow.scanner;

import javax.annotation.Nonnull;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;
import java.util.regex.Pattern;

import static java.lang.String.format;

public class ScannerExample
{
    private static final Set<String> EXIT_COMMANDS;
    private static final Set<String> HELP_COMMANDS;
    private static final Pattern DATE_PATTERN;
    private static final String HELP_MESSAGE;

    static
    {
        final SortedSet<String> ecmds = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
        ecmds.addAll(Arrays.asList("exit", "done", "quit", "end", "fino"));
        EXIT_COMMANDS = Collections.unmodifiableSortedSet(ecmds);
        final SortedSet<String> hcmds = new TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
        hcmds.addAll(Arrays.asList("help", "helpi", "?"));
        HELP_COMMANDS = Collections.unmodifiableSet(hcmds);
        DATE_PATTERN = Pattern.compile("\\d{4}([-\\/])\\d{2}\\1\\d{2}"); // http://regex101.com/r/xB8dR3/1
        HELP_MESSAGE = format("Please enter some data or enter one of the following commands to exit %s", EXIT_COMMANDS);
    }

    /**
     * Using exceptions to control execution flow is always bad.
     * That is why this is encapsulated in a method, this is done this
     * way specifically so as not to introduce any external libraries
     * so that this is a completely self contained example.
     * @param s possible url
     * @return true if s represents a valid url, false otherwise
     */
    private static boolean isValidURL(@Nonnull final String s)
    {
        try { new URL(s); return true; }
        catch (final MalformedURLException e) { return false; }
    }

    private static void output(@Nonnull final String format, @Nonnull final Object... args)
    {
        System.out.println(format(format, args));
    }

    public static void main(final String[] args)
    {
        final Scanner sis = new Scanner(System.in);
        output(HELP_MESSAGE);
        while (sis.hasNext())
        {
            if (sis.hasNextInt())
            {
                final int next = sis.nextInt();
                output("You entered an Integer = %d", next);
            }
            else if (sis.hasNextLong())
            {
                final long next = sis.nextLong();
                output("You entered a Long = %d", next);
            }
            else if (sis.hasNextDouble())
            {
                final double next = sis.nextDouble();
                output("You entered a Double = %f", next);
            }
            else if (sis.hasNext("\\d+"))
            {
                final BigInteger next = sis.nextBigInteger();
                output("You entered a BigInteger = %s", next);
            }
            else if (sis.hasNextBoolean())
            {
                final boolean next = sis.nextBoolean();
                output("You entered a Boolean representation = %s", next);
            }
            else if (sis.hasNext(DATE_PATTERN))
            {
                final String next = sis.next(DATE_PATTERN);
                output("You entered a Date representation = %s", next);
            }
            else // unclassified
            {
                final String next = sis.next();
                if (isValidURL(next))
                {
                    output("You entered a valid URL = %s", next);
                }
                else
                {
                    if (EXIT_COMMANDS.contains(next))
                    {
                        output("Exit command %s issued, exiting!", next);
                        break;
                    }
                    else if (HELP_COMMANDS.contains(next)) { output(HELP_MESSAGE); }
                    else { output("You entered an unclassified String = %s", next); }
                }
            }
        }
        /*
           This will close the underlying Readable, in this case System.in, and free those resources.
           You will not be to read from System.in anymore after this you call .close().
           If you wanted to use System.in for something else, then don't close the Scanner.
        */
        sis.close();
        System.exit(0);
    }
}

Lee un int desde la línea de comando

import java.util.Scanner;

Scanner s = new Scanner(System.in);
int number = s.nextInt();

Si desea leer un int desde la línea de comandos, solo use este fragmento. En primer lugar, debe crear un objeto Escáner, que escucha System.in, que es la línea de comandos de forma predeterminada, cuando inicia el programa desde la línea de comandos. Después de eso, con la ayuda del objeto Escáner, lee el primer int que el usuario pasa a la línea de comando y lo almacena en el número de variable. Ahora puedes hacer lo que quieras con ese int almacenado.

Cerrar cuidadosamente un escáner

puede suceder que use un escáner con el System.in como parámetro para el constructor, entonces debe tener en cuenta que al cerrar el escáner se cerrará también el InputStream, lo que hará que cada vez que intente leer la entrada (o cualquier otro) objeto de escáner) lanzará una java.util.NoSuchElementException o una java.lang.IllegalStateException

ejemplo:

    Scanner sc1 = new Scanner(System.in);
    Scanner sc2 = new Scanner(System.in);
    int x1 = sc1.nextInt();
    sc1.close();
    // java.util.NoSuchElementException
    int x2 = sc2.nextInt();
    // java.lang.IllegalStateException
    x2 = sc1.nextInt();