Comment utiliser java.util.Scanner pour lire correctement la saisie de l'utilisateur du Système.et agir sur elle?

Idiomatiques Exemple:

Voici comment utiliser correctement le java.util.Scanner classe interactive à la lecture du mode d'entrée de System.in correctement( parfois appelé stdin, en particulier en C, C++ et d'autres langues ainsi que dans les environnements Unix et Linux). Il idiomatique montre le plus commun de choses qui doivent être fait.

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 InputStream, in this case System.in, and free those resources.
WARNING: You will not be able to read from System.in anymore after you call .close().
If you wanted to use System.in for something else, then don't close the Scanner.
*/
sis.close();
System.exit(0);
}
}

Notes:

Cela peut ressembler à beaucoup de code, mais il illustre bien le minimum
l'effort nécessaire pour l'utilisation de la Scanner classe correctement et ne pas avoir à
traiter avec des bogues et des effets secondaires que la peste ceux qui sont nouveaux à
la programmation et que cela terriblement classe implémentée appelé
java.util.Scanner. Il tente d'illustrer ce que idiomatiques code Java
devrait ressembler et se comporter comme des.

Ci-dessous sont quelques-uns des choses que je pensais quand j'ai écrit cet exemple:

Version du JDK:

J'ai volontairement gardé cet exemple compatible avec le JDK 6. Si certains scénario vraiment exigences d'une fonction de JDK 7/8 je ou quelqu'un d'autre va poster une nouvelle réponse avec des détails sur la façon de modifier cette version du JDK.

La majorité des questions au sujet de cette classe viennent d'étudiants, et ils ont généralement des restrictions sur ce qu'ils peuvent utiliser pour résoudre un problème donc j'ai limité autant que je pouvais pour montrer comment faire les choses en commun, sans autres dépendances. Dans les 22 ans que je travaille avec Java et de consultation de la majorité de l'époque, je n'ai jamais rencontré une utilisation professionnelle de cette classe dans les 10 millions de lignes de code source que j'ai vu.

, Le traitement des commandes:

Cette montre exactement comment idiomatique les commandes de lecture de l'utilisateur de manière interactive et d'expédier les commandes. La majorité des questions au sujet de java.util.Scanner sont de la comment puis-je obtenir mon programme pour arrêter de fumer quand j'ai entrer certains de saisie spécifiques à catégorie. Cela montre clairement.

Naïf Répartiteur

L'envoi de la logique est volontairement naïf pour ne pas compliquer la solution pour les nouveaux lecteurs. Un répartiteur basé sur un Strategy Pattern ou Chain Of Responsibility modèle serait plus approprié pour les problèmes du monde réel qui serait beaucoup plus complexe.

Erreur De Manipulation

Le code a été délibérément structuré qu'elle ne nécessite aucune Exception la manipulation, car il n'y a pas de scénario où certaines données peuvent ne pas être correcte.

.hasNext() et .hasNextXxx()

J'ai rarement vu quelqu'un à l'aide de la .hasNext() correctement, par un test de dépistage pour le générique .hasNext() de contrôle de la boucle d'événements, puis à l'aide de la if(.hasNextXxx()) idiome vous permet de décider comment et quoi de procéder avec votre code sans avoir à se soucier de demander une int lorsqu'aucun n'est disponible, donc pas de code de gestion des exceptions.

.nextXXX() vs .nextLine()

C'est quelque chose qui brise tous les code. C'est un méticuleux du détail qui ne devraient pas être traitées et a une très obfusated bug qui est difficile à comprendre à cause de cela rompt le Principal de Moins d'Étonnement

La .nextXXX() méthodes ne consomment pas de la fin de ligne. .nextLine() .

Qui signifie que l'appel .nextLine() immédiatement après .nextXXX() sera juste retour de la fin de ligne. Il faut l'appeler de nouveau à réellement obtenir la ligne suivante.

C'est pourquoi beaucoup de gens le défenseur utiliser rien d'autre que la .nextXXX() méthodes ou seulement .nextLine() mais pas les deux en même temps, de sorte que ce comportement capricieux ne pas vous passionner. Personnellement, je pense que le type de méthodes sécuritaires sont beaucoup mieux que d'avoir à tester et analyser et de repérer les erreurs manuellement.

Immutablity:

Avis qu'il n'y a pas mutable variables utilisées dans le code, c'est important d'apprendre à le faire, il élimine quatre des plus grandes sources d'erreurs d'exécution et les bogues subtils.

1. Pas nulls signifie pas de possibilité d'une NullPointerExceptions!

2. Pas de mutabilité signifie que vous n'avez pas à vous soucier des arguments de méthode de changer ou quoi que ce soit d'autre en train de changer. Lors de l'étape de débogage à travers vous ne jamais avoir à utiliser watch pour voir quelles sont les variables changent pour quelles valeurs, si elles sont en train de changer. Cela rend la logique 100% déterministe quand vous la lisez.

3. Pas de mutabilité signifie que votre code est automatiquement thread-safe.

4. Pas d'effets secondaires. Si rien ne peut le changer, vous n'avez pas à vous inquiéter au sujet de certains de subtils effets secondaires de certains cas limites de changer quelque chose, de façon inattendue!

Lisez ceci si vous ne comprenez pas comment appliquer le final mot clé dans votre propre code.

L'aide d'un Jeu au lieu de massive switch ou if/elseif blocs:

Avis comment je utiliser un Set<String> et l'utilisation .contains() de classer les commandes à la place d'un massif de switch ou if/elseif monstruosité qui serait gonfler votre code et, plus important encore faire de l'entretien un cauchemar! L'ajout d'une nouvelle surcharge de commande est aussi simple que l'ajout d'un nouveau String de la matrice dans le constructeur.

Ce serait aussi très bien fonctionner avec i18n et i10n et la bonne ResourceBundles.
Un Map<Locale,Set<String>> serait vous permettent de prendre en charge plusieurs langues, avec très peu de frais généraux de!

@Non

J'ai décidé que tout mon code devrait explicitement déclarer si quelque chose est @Nonnull ou @Nullable. Elle permet à votre IDE de vous avertir sur le potentiel de NullPointerException dangers et quand vous n'avez pas à vérifier.

Le plus important des documents de l'attente pour les futurs lecteurs qu'aucun de ces paramètres de la méthode doit être null.

Appel .close()

Vraiment réfléchir avant de le faire.

Que pensez-vous qui va arriver System.in si vous appelez sis.close()? Voir les commentaires dans la liste ci-dessus.

Veuillez fourche et envoyer des pull requests et je mettrai à jour cette question et la réponse pour les autres scénarios d'utilisation.

OriginalL'auteur