Java Language
Scanner

Syntaxe

• Scanner scanner = nouveau scanner (source source);
• Scanner scanner = nouveau scanner (System.in);

Paramètres

Remarques

Lecture du système à l'aide du scanner

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

L'objet scanner est initialisé pour lire les entrées du clavier. Donc, pour l'entrée ci-dessous de keyboar, il produira la sortie en Reading from keyboard

Reading
from
keyboard
  //space

Lecture de l'entrée de fichier à l'aide de Scanner

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

Ici, un objet Scanner est créé en transmettant un objet File contenant le nom d'un fichier texte en entrée. Ce fichier texte sera ouvert par l'objet File et lu par l'objet scanner dans les lignes suivantes. scanner.hasNext() vérifiera s'il existe une ligne de données suivante dans le fichier texte. La combinaison de cela avec un while en boucle vous permettra de itérer chaque ligne de données dans le Names.txt fichier. Pour récupérer les données elles-mêmes, nous pouvons utiliser des méthodes telles que nextLine() , nextInt() , nextBoolean() , etc. Dans l'exemple ci-dessus, scanner.nextLine() est utilisé. nextLine() fait référence à la ligne suivante dans un fichier texte et sa combinaison avec un objet scanner vous permet d'imprimer le contenu de la ligne. Pour fermer un objet scanner, vous devez utiliser .close() .

En utilisant try with resources (à partir de Java 7), le code mentionné ci-dessus peut être écrit de manière élégante comme ci-dessous.

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

Lire l'intégralité de l'entrée sous forme de chaîne à l'aide de Scanner

Vous pouvez utiliser Scanner pour lire tout le texte dans l'entrée en tant que chaîne, en utilisant \Z (entrée entière) comme délimiteur. Par exemple, cela peut être utilisé pour lire tout le texte d'un fichier texte sur une seule ligne:

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

Rappelez-vous que vous devrez fermer le scanner, ainsi que le IoException cela peut IoException , comme décrit dans l'exemple Lecture de l'entrée de fichier à l'aide de Scanner .

Utilisation de délimiteurs personnalisés

Vous pouvez utiliser des délimiteurs personnalisés (expressions régulières) avec Scanner, avec .useDelimiter(",") , pour déterminer la manière dont l'entrée est lue. Cela fonctionne de la même manière que String.split(...) . Par exemple, vous pouvez utiliser Scanner pour lire une liste de valeurs séparées par des virgules dans une chaîne:

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

Cela vous permettra de lire chaque élément de l'entrée individuellement. Notez que vous ne devez pas l' utiliser pour analyser les données CSV, utilisez plutôt une bibliothèque d'analyseur CSV appropriée, voir l' analyseur CSV pour Java pour d'autres possibilités.

Modèle général qui pose le plus souvent des questions sur les tâches

La procédure suivante explique comment utiliser correctement la classe java.util.Scanner pour lire de manière interactive les entrées utilisateur de System.in (parfois appelées stdin , notamment en C, C ++ et autres langages ainsi que sous Unix et Linux). Il montre automatiquement les choses les plus courantes qui doivent être effectuées.

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

Lire un int depuis la ligne de commande

import java.util.Scanner;

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

Si vous souhaitez lire un int à partir de la ligne de commande, utilisez simplement cet extrait. Tout d'abord, vous devez créer un objet Scanner, qui écoute System.in, qui est par défaut la ligne de commande, lorsque vous démarrez le programme à partir de la ligne de commande. Après cela, à l'aide de l'objet Scanner, vous lisez le premier int que l'utilisateur passe dans la ligne de commande et le stockez dans le numéro de variable. Maintenant, vous pouvez faire ce que vous voulez avec ce stocké.

Fermer soigneusement un scanner

il peut arriver que vous utilisiez un scanner avec le paramètre System.in en tant que paramètre pour le constructeur, alors vous devez être conscient que la fermeture du scanner fermera le InputStream en donnant la prochaine fois que chaque tentative de lecture de l'entrée sur ce dernier (ou tout autre objet scanner) lancera une java.util.NoSuchElementException ou une java.lang.IllegalStateException

Exemple:

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