Comment puis-je obtenir la saisie de l'utilisateur en Java?
J'ai essayé de créer une calculatrice, mais je ne parviens pas à la faire fonctionner car je ne sais pas comment obtenir une entrée utilisateur .
Comment puis-je obtenir la saisie de l'utilisateur en Java?
L’un des moyens les plus simples consiste à utiliser un objet Scanner comme suit:
import Java.util.Scanner;
Scanner reader = new Scanner(System.in); // Reading from System.in
System.out.println("Enter a number: ");
int n = reader.nextInt(); // Scans the next token of the input as an int.
//once finished
reader.close();
Vous pouvez utiliser l'une des options suivantes en fonction des exigences.
Scanner class
import Java.util.Scanner;
Scanner scan = new Scanner(System.in);
String s = scan.next();
int i = scan.nextInt();
BufferedReader et InputStreamReader classes
import Java.io.BufferedReader;
import Java.io.InputStreamReader;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = br.readLine();
int i = Integer.parseInt(br.readLine());
DataInputStream class
import Java.io.DataInputStream;
DataInputStream dis = new DataInputStream(System.in);
int i = dis.readInt();
La méthode readLine de la classe DataInputStream a été deprecated. Pour obtenir la valeur String, vous devez utiliser la solution précédente avec BufferedReader.
Console class
import Java.io.Console;
Console console = System.console();
String s = console.readLine();
int i = Integer.parseInt(console.readLine());
Apparemment, cette méthode ne fonctionne pas bien dans certains IDE.
Vous pouvez utiliser le Scanner class ou la classe Console
Console console = System.console();
String input = console.readLine("Enter input:");
Vous pouvez obtenir la saisie de l'utilisateur à l'aide de BufferedReader .
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String accStr;
System.out.println("Enter your Account number: ");
accStr = br.readLine();
Il va stocker une valeur String dans accStr et vous devez donc l'analyser en une int en utilisant Integer.parseInt .
int accInt = Integer.parseInt(accStr);
Voici comment vous pouvez obtenir les entrées au clavier:
Scanner scanner = new Scanner (System.in);
System.out.print("Enter your name");
name = scanner.next(); // Get what the user types.
Vous pouvez créer un programme simple pour demander le nom de l'utilisateur et imprimer toutes les réponses utilisées.
Vous pouvez également demander à l’utilisateur de saisir deux nombres. Vous pouvez ensuite ajouter, multiplier, soustraire ou diviser ces chiffres et imprimer les réponses pour les saisies de l’utilisateur, comme pour le comportement d’une calculatrice.
Donc là vous avez besoin de la classe de scanner. Vous devez import Java.util.Scanner; et dans le code que vous devez utiliser
Scanner input = new Scanner(System.in);
L'entrée est un nom de variable.
Scanner input = new Scanner(System.in);
System.out.println("Please enter your name : ");
s = input.next(); // getting a String value
System.out.println("Please enter your age : ");
i = input.nextInt(); // getting an integer
System.out.println("Please enter your salary : ");
d = input.nextDouble(); // getting a double
Voyez en quoi cela diffère: input.next();, i = input.nextInt();, d = input.nextDouble();
Selon une chaîne, int et un double varient de la même manière pour le reste. N'oubliez pas la déclaration d'importation en haut de votre code.
Voir également l'article de blog "Classe de scanner et obtention des entrées d'utilisateur" .
Pour lire une ligne ou une chaîne, vous pouvez utiliser un objet BufferedReader combiné à un InputStreamReader comme suit:
BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
String inputLine = bufferReader.readLine();
Ici, le programme demande à l'utilisateur d'entrer un numéro. Après cela, le programme imprime les chiffres du nombre et la somme des chiffres.
import Java.util.Scanner;
public class PrintNumber {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int num = 0;
int sum = 0;
System.out.println(
"Please enter a number to show its digits");
num = scan.nextInt();
System.out.println(
"Here are the digits and the sum of the digits");
while (num > 0) {
System.out.println("==>" + num % 10);
sum += num % 10;
num = num / 10;
}
System.out.println("Sum is " + sum);
}
}
Voici votre programme de la question en utilisant Java.util.Scanner:
import Java.util.Scanner;
public class Example {
public static void main(String[] args) {
int input = 0;
System.out.println("The super insano calculator");
System.out.println("enter the corrosponding number:");
Scanner reader3 = new Scanner(System.in);
System.out.println(
"1. Add | 2. Subtract | 3. Divide | 4. Multiply");
input = reader3.nextInt();
int a = 0, b = 0;
Scanner reader = new Scanner(System.in);
System.out.println("Enter the first number");
// get user input for a
a = reader.nextInt();
Scanner reader1 = new Scanner(System.in);
System.out.println("Enter the scend number");
// get user input for b
b = reader1.nextInt();
switch (input){
case 1: System.out.println(a + " + " + b + " = " + add(a, b));
break;
case 2: System.out.println(a + " - " + b + " = " + subtract(a, b));
break;
case 3: System.out.println(a + " / " + b + " = " + divide(a, b));
break;
case 4: System.out.println(a + " * " + b + " = " + multiply(a, b));
break;
default: System.out.println("your input is invalid!");
break;
}
}
static int add(int lhs, int rhs) { return lhs + rhs; }
static int subtract(int lhs, int rhs) { return lhs - rhs; }
static int divide(int lhs, int rhs) { return lhs / rhs; }
static int multiply(int lhs, int rhs) { return lhs * rhs; }
}
Juste un détail supplémentaire. Si vous ne voulez pas risquer une fuite de mémoire/ressource, fermez le flux du scanner lorsque vous avez terminé:
myScanner.close();
Notez que Java 1.7 et les versions ultérieures voient cela comme un avertissement lors de la compilation (ne demandez pas comment je le sais :-)
Entrée scanner = nouveau scanner (System.in); int entier = input.nextInt (); Chaîne string = input.next (); long longInteger = input.nextLong ();
Utilisez la classe System pour obtenir l’entrée.
http://fresh2refresh.com/Java-tutorial/Java-input-output/ :
Comment les données sont acceptées à partir du clavier?
Nous avons besoin de trois objets,
- System.in
- InputStreamReader
BufferedReader
- InputStreamReader et BufferedReader sont des classes du package Java.io.
- Les données sont reçues sous forme d'octets depuis le clavier par System.in qui est un objet InputStream.
- Ensuite, InputStreamReader lit les octets et les décode en caractères.
- Enfin, l’objet BufferedReader lit le texte d’un flux de saisie de caractères et met en mémoire tampon les caractères de manière à permettre une lecture efficace des caractères, des tableaux et des lignes.
InputStreamReader inp = new InputStreamReader(system.in);
BufferedReader br = new BufferedReader(inp);
import Java.util.Scanner;
class Daytwo{
public static void main(String[] args){
System.out.println("HelloWorld");
Scanner reader = new Scanner(System.in);
System.out.println("Enter the number ");
int n = reader.nextInt();
System.out.println("You entered " + n);
}
}
Les deux meilleures options sont BufferedReader et Scanner.
La méthode la plus largement utilisée est Scanner et je la préfère personnellement en raison de sa simplicité et de sa facilité de mise en œuvre, ainsi que de son puissant utilitaire pour analyser du texte en données primitives.
Avantages de l'utilisation du scanner
- Facile à utiliser la classe
Scanner - Saisie facile de nombres (int, court, octet, float, long et double)}
- Les exceptions sont décochées, ce qui est plus pratique. Il appartient au programmeur d’être civilisé et de spécifier ou d’attraper les exceptions.
- Est capable de lire des lignes, des espaces et des jetons délimités par une expression régulière
Avantages de BufferedInputStream
- BufferedInputStream consiste à lire des blocs de données plutôt qu'un octet à la fois.
- Peut lire des caractères, des tableaux de caractères et des lignes
- Lance les exceptions vérifiées
- Performance rapide
- Synchronisé ( vous ne pouvez pas partager
Scannerentre les threads )
Dans l’ensemble, chaque méthode d’entrée a des objectifs différents.
Si vous saisissez une grande quantité de données,
BufferedReaderpourrait être Meilleur pour vousSi vous entrez beaucoup de nombres,
Scannereffectue l'analyse automatique .__, ce qui est très pratique
Pour des utilisations plus basiques, je recommanderais la Scanner car il est plus facile à utiliser et à écrire des programmes. Voici un exemple rapide sur la façon de créer une Scanner. Je vais donner un exemple complet ci-dessous sur la façon d’utiliser Scanner
Scanner scanner = new Scanner (System.in); // create scanner
System.out.print("Enter your name"); // Prompt user
name = scanner.next(); // get user input
(Pour plus d'informations sur BufferedReader, voir Comment utiliser un lecteur BufferedReader et voir Lignes de lecture de caractères )
Java.util.Scanner
import Java.util.InputMismatchException; // import the exception catching class
import Java.util.Scanner; // import the scanner class
public class RunScanner {
// main method which will run your program
public static void main(String args[]) {
// create your new scanner
// Note: since scanner is opened to "System.in" closing it will close "System.in".
// Do not close scanner until you no longer want to use it at all.
Scanner scanner = new Scanner(System.in);
// Prompt THE USER
// Note: when using scanner it is recommended to Prompt the user with "System.out.print" or "System.out.println"
System.out.println("Please enter a number");
// use "try" to catch invalid inputs
try {
// get integer with "nextInt()"
int n = scanner.nextInt();
System.out.println("Please enter a decimal"); // Prompt
// get decimal with "nextFloat()"
float f = scanner.nextFloat();
System.out.println("Please enter a Word"); // Prompt
// get single Word with "next()"
String s = scanner.next();
// ---- Note: Scanner.nextInt() does not consume a nextLine character /n
// ---- In order to read a new line we first need to clear the current nextLine by reading it:
scanner.nextLine();
// ----
System.out.println("Please enter a line"); // Prompt
// get line with "nextLine()"
String l = scanner.nextLine();
// do something with the input
System.out.println("The number entered was: " + n);
System.out.println("The decimal entered was: " + f);
System.out.println("The Word entered was: " + s);
System.out.println("The line entered was: " + l);
}
catch (InputMismatchException e) {
System.out.println("\tInvalid input entered. Please enter the specified input");
}
scanner.close(); // close the scanner so it doesn't leak
}
}
Remarque: D'autres classes telles que Console et DataInputStream sont également des alternatives viables.
Console a quelques fonctionnalités puissantes telles que la capacité de lire les mots de passe, cependant, n'est pas disponible dans tous les IDE (comme Eclipse). Cela s’explique par le fait qu’Eclipse exécute votre application en tant que processus en arrière-plan et non en tant que processus de niveau supérieur avec une console système. Voici un lien vers un exemple utile sur la façon d'implémenter la classe Console.
DataInputStream est principalement utilisé pour lire les entrées en tant que type de données primitif, à partir d'un flux d'entrée sous-jacent, d'une manière indépendante de la machine. DataInputStream est généralement utilisé pour lire des données binaires. Il fournit également des méthodes pratiques pour lire certains types de données. Par exemple, il existe une méthode pour lire une chaîne UTF pouvant contenir un nombre quelconque de lignes.
Cependant, il s'agit d'une classe plus compliquée et plus difficile à mettre en œuvre, donc déconseillée aux débutants. Voici un lien vers un exemple utile sur la manière de mettre en œuvre une DataInputStream.
Voici une version plus développée de la réponse acceptée qui répond à deux besoins communs:
- Collecte des entrées utilisateur à plusieurs reprises jusqu'à ce qu'une valeur de sortie ait été entrée
- Traitement des valeurs d'entrée non valides (non entiers dans cet exemple)
Code
package inputTest;
import Java.util.Scanner;
import Java.util.InputMismatchException;
public class InputTest {
public static void main(String args[]) {
Scanner reader = new Scanner(System.in);
System.out.println("Please enter integers. Type 0 to exit.");
boolean done = false;
while (!done) {
System.out.print("Enter an integer: ");
try {
int n = reader.nextInt();
if (n == 0) {
done = true;
}
else {
// do something with the input
System.out.println("\tThe number entered was: " + n);
}
}
catch (InputMismatchException e) {
System.out.println("\tInvalid input type (must be an integer)");
reader.nextLine(); // Clear invalid input from scanner buffer.
}
}
System.out.println("Exiting...");
reader.close();
}
}
Exemple
Please enter integers. Type 0 to exit.
Enter an integer: 12
The number entered was: 12
Enter an integer: -56
The number entered was: -56
Enter an integer: 4.2
Invalid input type (must be an integer)
Enter an integer: but i hate integers
Invalid input type (must be an integer)
Enter an integer: 3
The number entered was: 3
Enter an integer: 0
Exiting...
Notez que sans nextLine(), la mauvaise entrée déclenchera la même exception à plusieurs reprises dans une boucle infinie. Vous voudrez peut-être utiliser next() à la place, en fonction des circonstances, mais sachez qu'une entrée telle que this has spaces générera plusieurs exceptions.
Il est très simple d'obtenir des entrées en Java. Tout ce que vous avez à faire est:
import Java.util.Scanner;
class GetInputFromUser
{
public static void main(String args[])
{
int a;
float b;
String s;
Scanner in = new Scanner(System.in);
System.out.println("Enter a string");
s = in.nextLine();
System.out.println("You entered string " + s);
System.out.println("Enter an integer");
a = in.nextInt();
System.out.println("You entered integer " + a);
System.out.println("Enter a float");
b = in.nextFloat();
System.out.println("You entered float " + b);
}
}
import Java.util.Scanner;
public class Myapplication{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int a;
System.out.println("enter:");
a = in.nextInt();
System.out.println("Number is= " + a);
}
}
Scanner input = new Scanner(System.in);
String inputval = input.next();
Ajoutez throws IOException à côté de main(), puis
DataInputStream input = new DataInputStream(System.in);
System.out.print("Enter your name");
String name = input.readLine();
Peut être quelque chose comme ça ...
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
System.out.println("Enter a number: ");
int i = reader.nextInt();
for (int j = 0; j < i; j++)
System.out.println("I love Java");
}
Vous pouvez obtenir une entrée utilisateur comme celle-ci en utilisant un BufferedReader:
InputStreamReader inp = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(inp);
// you will need to import these things.
Voici comment vous les appliquez
String name = br.readline();
Ainsi, lorsque l'utilisateur saisit son nom dans la console, "Nom de chaîne" stockera ces informations.
Si vous souhaitez enregistrer un numéro, le code ressemblera à ceci:
int x = Integer.parseInt(br.readLine());
Hop ça aide!
J'aime ce qui suit:
public String readLine(String tPromptString) {
byte[] tBuffer = new byte[256];
int tPos = 0;
System.out.print(tPromptString);
while(true) {
byte tNextByte = readByte();
if(tNextByte == 10) {
return new String(tBuffer, 0, tPos);
}
if(tNextByte != 13) {
tBuffer[tPos] = tNextByte;
++tPos;
}
}
}
et par exemple, je ferais:
String name = this.readLine("What is your name?")
C'est un code simple qui utilise la fonction System.in.read(). Ce code écrit simplement ce qui a été tapé. Vous pouvez vous débarrasser de la boucle while si vous voulez juste prendre une entrée une fois et vous pouvez stocker les réponses dans un tableau de caractères si vous le souhaitez.
package main;
import Java.io.IOException;
public class Root
{
public static void main(String[] args)
{
new Root();
}
public Root()
{
while(true)
{
try
{
for(int y = 0; y < System.in.available(); ++y)
{
System.out.print((char)System.in.read());
}
}
catch(IOException ex)
{
ex.printStackTrace(System.out);
break;
}
}
}
}
La saisie au clavier à l'aide de Scanner est possible, comme d'autres l'ont postée. Mais en ces temps très graphiques, il est inutile de créer une calculatrice sans interface graphique.
En Java moderne, cela signifie utiliser un outil de glisser-déposer JavaFX tel que Scene Builder pour disposer une interface graphique ressemblant à une console de calculatrice. Notez que l'utilisation de Scene Builder est intuitivement simple et n'exige aucune compétence Java supplémentaire pour ses gestionnaires d'événements.
Pour une entrée utilisateur, vous devez avoir un champ TextField large en haut de la console graphique.
C’est là que l’utilisateur entre les nombres sur lesquels il souhaite exécuter des fonctions . Sous le champ TextField, vous disposerez d’un tableau de boutons de fonction effectuant des fonctions de base (c.-à-d. Ajouter/soustraire/multiplier/diviser et mémoire/rappeler/effacer) . Une fois l'interface graphique affichée, vous pouvez ajouter les références de «contrôleur» reliant chaque fonction de bouton à son implémentation Java, par exemple un appel à method dans la classe de contrôleur de votre projet.
Cette vidéo est un peu ancienne mais montre toujours à quel point Scene Builder est facile à utiliser.
Vous pouvez obtenir la saisie de l'utilisateur en utilisant Scanner. Vous pouvez utiliser la validation d'entrée appropriée en utilisant des méthodes appropriées pour différents types de données, comme next() pour String ou nextInt() pour Integer.
import Java.util.Scanner;
Scanner scanner = new Scanner(System.in);
//reads the input until it reaches the space
System.out.println("Enter a string: ");
String str = scanner.next();
System.out.println("str = " + str);
//reads until the end of line
String aLine = scanner.nextLine();
//reads the integer
System.out.println("Enter an integer num: ");
int num = scanner.nextInt();
System.out.println("num = " + num);
//reads the double value
System.out.println("Enter a double: ");
double aDouble = scanner.nextDouble();
System.out.println("double = " + aDouble);
//reads the float value, long value, boolean value, byte and short
double aFloat = scanner.nextFloat();
long aLong = scanner.nextLong();
boolean aBoolean = scanner.nextBoolean();
byte aByte = scanner.nextByte();
short aShort = scanner.nextShort();
scanner.close();