Comment obtenir l'entrée utilisateur en Java?

J'ai tenté de créer une calculatrice, mais je n'arrive pas à la faire fonctionner car je ne sais pas comment obtenir les entrées des utilisateurs .

Comment puis-je obtenir l'entrée utilisateur en Java?

Vous pouvez utiliser l'une des options suivantes en fonction des exigences.

Scanner classe

import java.util.Scanner; 
Scanner scan = new Scanner(System.in);
String s = scan.next();
int i = scan.nextInt();

BufferedReaderet InputStreamReadercours

import java.io.BufferedReader;
import java.io.InputStreamReader;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s = br.readLine();
int i = Integer.parseInt(s);

DataInputStream classe

import java.io.DataInputStream;
DataInputStream dis = new DataInputStream(System.in);
int i = dis.readInt();

La readLineméthode de la DataInputStreamclasse est obsolète . Pour obtenir la valeur de chaîne, vous devez utiliser la solution précédente avec BufferedReader

Console classe

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.

L'un des moyens les plus simples consiste à utiliser un Scannerobjet 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 la classe Scanner ou la classe Console

Console console = System.console();
String input = console.readLine("Enter input:");

Vous pouvez obtenir une entrée 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 stockera une Stringvaleur dans accStrvous devez donc l'analyser en intutilisant Integer.parseInt.

int accInt = Integer.parseInt(accStr);

Voici comment obtenir les entrées 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 ce que la réponse utilise.

Ou demandez à l'utilisateur d'entrer deux nombres et vous pouvez ajouter, multiplier, soustraire ou diviser ces nombres et imprimer les réponses pour les entrées utilisateur, tout comme le comportement d'une calculatrice.

Vous avez donc besoin de la classe 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 comment 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 le billet de blog "Classe du scanner et obtention des entrées utilisateur" .

Les deux meilleures options sont BufferedReaderet Scanner.

La méthode la plus largement utilisée est Scanneret je la préfère personnellement en raison de sa simplicité et de sa mise en œuvre facile, ainsi que de sa puissante utilité pour analyser le texte en données primitives.

Avantages de l'utilisation du scanner

• Facile à utiliser la Scannerclasse
• Saisie facile des nombres (int, court, octet, flottant, long et double)
• Les exceptions ne sont pas vérifiées, ce qui est plus pratique. Il appartient au programmeur d'être civilisé et de spécifier ou d'intercepter les exceptions.
• Est capable de lire les lignes, les espaces blancs et les jetons délimités par des expressions rationnelles

Avantages de BufferedInputStream

• BufferedInputStream consiste à lire des blocs de données plutôt qu'un seul octet à la fois
• Peut lire les caractères, les tableaux de caractères et les lignes
• Lève les exceptions vérifiées
• Performances rapides
• Synchronisé ( vous ne pouvez pas partager Scannerentre les threads )

Globalement, chaque méthode d'entrée a des objectifs différents.

• Si vous saisissez une grande quantité de données, cela BufferedReaderpourrait être mieux pour vous

• Si vous entrez de nombreux nombres, Scannerl'analyse automatique est très pratique

Pour des utilisations plus basiques, je recommanderais le Scannercar il est plus facile à utiliser et plus facile à écrire avec des programmes. Voici un exemple rapide de création d'un fichier Scanner. Je vais fournir un exemple complet ci-dessous de la façon d'utiliser leScanner

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 les BufferedReadervoir Comment utiliser un BufferedReader et voir les lignes de lecture de Chars )

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 Consoleet DataInputStreamsont également des alternatives viables.}

^{Consolea 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). La raison en est que Eclipse exécute votre application en tant que processus d'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 Consoleclasse.}

^{DataInputStreamest principalement utilisé pour lire l'entrée 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. DataInputStreamest 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 a une méthode pour lire une chaîne UTF qui peut contenir n'importe quel nombre de lignes.}

^{Cependant, c'est une classe plus compliquée et plus difficile à implémenter, donc déconseillée aux débutants. Voici un lien vers un exemple utile pour implémenter un DataInputStream.}

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

Pour lire une ligne ou une chaîne, vous pouvez utiliser un BufferedReaderobjet combiné avec un InputStreamReadercomme suit:

BufferedReader bufferReader = new BufferedReader(new InputStreamReader(System.in));
String inputLine = bufferReader.readLine();

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

Utilisez la Systemclasse pour obtenir l'entrée.

http://fresh2refresh.com/java-tutorial/java-input-output/ :

Comment les données sont-elles acceptées à partir du clavier?

Nous avons besoin de trois objets,

1. System.in
2. InputStreamReader

3. BufferedReader

   • InputStreamReader et BufferedReader sont des classes du package java.io.
   • Les données sont reçues sous forme d'octets du 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 à partir d'un flux d'entrée de caractères, en tamponnant 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);

Entrée scanner = nouveau scanner (System.in);
int entier = input.nextInt ();
String string = input.next ();
long longInteger = input.nextLong ();

Juste un détail supplémentaire. Si vous ne voulez pas risquer une fuite de mémoire / ressource, vous devez fermer le flux du scanner lorsque vous avez terminé:

myScanner.close();

Notez que java 1.7 et versions ultérieures interceptent cela comme un avertissement de compilation (ne me demandez pas comment je le sais :-)

Scanner input = new Scanner(System.in);
String inputval = input.next();

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

    }
}

Voici une version plus développée de la réponse acceptée qui répond à deux besoins communs:

• Collecte répétée des entrées utilisateur jusqu'à ce qu'une valeur de sortie ait été entrée
• Traiter les valeurs d'entrée non valides (non entières 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 à la next()place en fonction des circonstances, mais sachez que l'entrée comme this has spacesgénérera plusieurs exceptions.

Ajouter à throws IOExceptioncôté main(), puis

DataInputStream input = new DataInputStream(System.in);
System.out.print("Enter your name");
String name = input.readLine();

Il est très simple d'obtenir des entrées en java, tout ce que vous avez à faire est de:

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

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, "String name" stockera ces informations.

Si c'est un numéro que vous souhaitez stocker, le code ressemblera à ceci:

    int x = Integer.parseInt(br.readLine());

Espérons que cela aide!

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

Il s'agit d'un code simple qui utilise la System.in.read()fonction. Ce code écrit juste ce qui a été tapé. Vous pouvez vous débarrasser de la boucle while si vous voulez simplement saisir 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;
            }
        }
    }   
}    

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?")

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        System.out.println("Welcome to the best program in the world! ");
        while (true) {
            System.out.print("Enter a query: ");
            Scanner scan = new Scanner(System.in);
            String s = scan.nextLine();
            if (s.equals("q")) {
                System.out.println("The program is ending now ....");
                break;
            } else  {
                System.out.println("The program is running...");
            }
        }
    }
}

Vous pouvez obtenir l'entrée utilisateur à l'aide de 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 Stringou 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();

Le moyen le plus simple d'obtenir les commentaires des utilisateurs serait d'utiliser le scanner. Voici un exemple de la façon dont il est censé être utilisé:

import java.util.Scanner;
public class main {
public static void main(String[]args) {
Scanner sc=new Scanner(System.in);
int a;
String b;
System.out.println("Type an integer here: ");
a=sc.nextInt();
System.out.println("Type anything here:");
b=sc.nextLine();

La ligne de code import java.util.Scanner;indique au programme que le programmeur utilisera les entrées utilisateur dans son code. Comme il est dit, il importe l'utilitaire du scanner. Scanner sc=new Scanner(System.in);indique au programme de démarrer les entrées utilisateur. Après cela, vous devez créer une chaîne ou un entier sans valeur, puis les mettre dans la ligne a=sc.nextInt();ou a=sc.nextLine();. Cela donne aux variables la valeur des entrées utilisateur. Ensuite, vous pouvez l'utiliser dans votre code. J'espère que cela t'aides.

import java.util.Scanner;

public class userinput {
    public static void main(String[] args) {        
        Scanner input = new Scanner(System.in);

        System.out.print("Name : ");
        String name = input.next();
        System.out.print("Last Name : ");
        String lname = input.next();
        System.out.print("Age : ");
        byte age = input.nextByte();

        System.out.println(" " );
        System.out.println(" " );

        System.out.println("Firt Name: " + name);
        System.out.println("Last Name: " + lname);
        System.out.println("      Age: " + age);
    }
}

class ex1 {    
    public static void main(String args[]){
        int a, b, c;
        a = Integer.parseInt(args[0]);
        b = Integer.parseInt(args[1]);
        c = a + b;
        System.out.println("c = " + c);
    }
}
// Output  
javac ex1.java
java ex1 10 20 
c = 30

La saisie au clavier à l'aide du scanner est possible, comme d'autres l'ont signalé. Mais en ces temps très graphiques, il est inutile de faire une calculatrice sans interface utilisateur graphique (GUI).

En Java moderne, cela signifie utiliser un outil de glisser-déposer JavaFX comme Scene Builder pour disposer une interface graphique qui ressemble à la console d'une calculatrice. Notez que l'utilisation de Scene Builder est intuitivement facile et ne nécessite aucune compétence Java supplémentaire pour ses gestionnaires d'événements que ce que vous possédez déjà.

Pour l'entrée utilisateur, vous devriez avoir un large TextField en haut de la console GUI.

C'est là que l'utilisateur saisit les numéros sur lesquels il souhaite exécuter des fonctions. En dessous du TextField, vous auriez un tableau de boutons de fonction effectuant des fonctions de base (c'est-à-dire ajouter / soustraire / multiplier / diviser et mémoire / rappeler / effacer). Une fois l'interface graphique déployée, vous pouvez ensuite ajouter les références «contrôleur» qui lient chaque fonction de bouton à son implémentation Java, par exemple un appel à la méthode 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.