¿Cómo obtener la entrada del usuario en Java?

Intenté crear una calculadora, pero no puedo hacer que funcione porque no sé cómo obtener información del usuario .

¿Cómo puedo obtener la entrada del usuario en Java?

Puede usar cualquiera de las siguientes opciones según los requisitos.

Scanner clase

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

BufferedReadery InputStreamReaderclases

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 clase

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

El readLinemétodo de la DataInputStreamclase ha quedado en desuso . Para obtener el valor de cadena, debe usar la solución anterior con BufferedReader

Console clase

import java.io.Console;
Console console = System.console();
String s = console.readLine();
int i = Integer.parseInt(console.readLine());

Aparentemente, este método no funciona bien en algunos IDE.

Una de las formas más simples es usar un Scannerobjeto de la siguiente manera:

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

Puedes usar la clase Scanner o la clase Console

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

Puede obtener la entrada del usuario utilizando BufferedReader.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String accStr;  

System.out.println("Enter your Account number: ");
accStr = br.readLine();

Almacenará un Stringvalor en, accStrpor lo que debe analizarlo en un intuso Integer.parseInt.

int accInt = Integer.parseInt(accStr);

Aquí es cómo puede obtener las entradas del teclado:

Scanner scanner = new Scanner (System.in);
System.out.print("Enter your name");  
name = scanner.next(); // Get what the user types.

Puede hacer un programa simple para pedir el nombre del usuario e imprimir cualquier entrada que use la respuesta.

O solicite al usuario que ingrese dos números y puede sumar, multiplicar, restar o dividir esos números e imprimir las respuestas para las entradas del usuario, como el comportamiento de una calculadora.

Entonces allí necesitas la clase Scanner. Tienes que import java.util.Scanner;y en el código que necesitas usar

Scanner input = new Scanner(System.in);

La entrada es un nombre 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

Ver en qué se diferencia: input.next();, i = input.nextInt();,d = input.nextDouble();

Según una cadena, int y un doble varían de la misma manera para el resto. No olvide la declaración de importación en la parte superior de su código.

Consulte también la publicación del blog "Clase de escáner y obtención de entradas de usuario" .

Las dos mejores opciones son BufferedReadery Scanner.

El método más utilizado es Scannery personalmente lo prefiero debido a su simplicidad y fácil implementación, así como a su poderosa utilidad para analizar texto en datos primitivos.

Ventajas de usar el escáner

• Fácil de usar la Scannerclase
• Fácil entrada de números (int, short, byte, float, long y double)
• Las excepciones no están marcadas, lo cual es más conveniente. Depende del programador ser civilizado y especificar o capturar las excepciones.
• Puede leer líneas, espacios en blanco y tokens delimitados por expresiones regulares.

Ventajas de BufferedInputStream

• BufferedInputStream se trata de leer en bloques de datos en lugar de un solo byte a la vez
• Puede leer caracteres, matrices de caracteres y líneas.
• Lanza excepciones marcadas
• Rendimiento rápido
• Sincronizado ( no puede compartir Scannerentre hilos )

En general, cada método de entrada tiene diferentes propósitos.

• Si está ingresando una gran cantidad de datos, BufferedReaderpodría ser mejor para usted

• Si está ingresando muchos números Scanner, el análisis automático es muy conveniente

Para usos más básicos, recomendaría el Scannerporque es más fácil de usar y es más fácil escribir programas. Aquí hay un ejemplo rápido de cómo crear un Scanner. Proporcionaré un ejemplo completo a continuación sobre cómo usar elScanner

Scanner scanner = new Scanner (System.in); // create scanner
System.out.print("Enter your name");       // prompt user
name = scanner.next();                     // get user input

(Para obtener más información sobre BufferedReaderver Cómo utilizar un BufferedReader y ver las líneas de lectura de Caracteres )

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

^{Nota: Otras clases como Consoley DataInputStreamtambién son alternativas viables.}

^{Consoletiene algunas características poderosas, como la capacidad de leer contraseñas, sin embargo, no está disponible en todos los IDE (como Eclipse). La razón de esto ocurre porque Eclipse ejecuta su aplicación como un proceso en segundo plano y no como un proceso de nivel superior con una consola del sistema. Aquí hay un enlace a un ejemplo útil sobre cómo implementar la Consoleclase.}

^{DataInputStreamse usa principalmente para leer la entrada como un tipo de datos primitivo, desde un flujo de entrada subyacente, de forma independiente de la máquina. DataInputStreamgeneralmente se usa para leer datos binarios. También proporciona métodos convenientes para leer ciertos tipos de datos. Por ejemplo, tiene un método para leer una cadena UTF que puede contener cualquier número de líneas dentro de ellas.}

^{Sin embargo, es una clase más complicada y más difícil de implementar, por lo que no se recomienda para principiantes. Aquí hay un enlace a un ejemplo útil de cómo implementar a DataInputStream.}

Aquí, el programa le pide al usuario que ingrese un número. Después de eso, el programa imprime los dígitos del número y la suma de los dígitos.

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

Para leer una línea o una cadena, puede usar un BufferedReaderobjeto combinado con InputStreamReaderuno de la siguiente manera:

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

Aquí está su programa de la pregunta usando 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; }
}

Use la Systemclase para obtener la entrada.

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

¿Cómo se aceptan los datos del teclado?

Necesitamos tres objetos,

1. System.in
2. InputStreamReader

3. BufferedReader

   • InputStreamReader y BufferedReader son clases en el paquete java.io.
   • System.in, que es un objeto InputStream, recibe los datos en forma de bytes desde el teclado.
   • Luego, InputStreamReader lee bytes y los decodifica en caracteres.
   • Luego, finalmente, el objeto BufferedReader lee el texto de una secuencia de entrada de caracteres, almacenando caracteres en búfer para proporcionar una lectura eficiente de caracteres, matrices y líneas.

InputStreamReader inp = new InputStreamReader(system.in);
BufferedReader br = new BufferedReader(inp);

Entrada del escáner = nuevo escáner (System.in);
int entero = input.nextInt ();
Cadena cadena = input.next ();
long longInteger = input.nextLong ();

Solo un detalle extra. Si no desea arriesgarse a una pérdida de memoria / recursos, debe cerrar la secuencia del escáner cuando haya terminado:

myScanner.close();

Tenga en cuenta que Java 1.7 y versiones posteriores captan esto como una advertencia de compilación (no pregunte cómo sé eso :-)

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

    }
}

Aquí hay una versión más desarrollada de la respuesta aceptada que aborda dos necesidades comunes:

• Recopilar la entrada del usuario repetidamente hasta que se haya ingresado un valor de salida
• Manejo de valores de entrada no válidos (no enteros en este ejemplo)

Código

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

Ejemplo

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...

Tenga en cuenta que sin nextLine(), la entrada incorrecta activará la misma excepción repetidamente en un bucle infinito. Es posible que desee usar next()en su lugar según las circunstancias, pero sepa que las entradas como this has spacesgenerarán múltiples excepciones.

Agregar throws IOExceptional lado main(), luego

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

Es muy sencillo obtener información en Java, todo lo que tiene que hacer es:

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

Puede obtener una entrada del usuario como esta usando un BufferedReader:

    InputStreamReader inp = new InputStreamReader(System.in);
    BufferedReader br = new BufferedReader(inp);
    // you will need to import these things.

Así es como los aplicas

    String name = br.readline(); 

Entonces, cuando el usuario escribe su nombre en la consola, "String name" almacenará esa información.

Si es un número que desea almacenar, el código se verá así:

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

¡Espero que esto ayude!

Puede ser algo como esto ...

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

Este es un código simple que usa la System.in.read()función. Este código solo escribe lo que se haya escrito. Puede deshacerse del ciclo while si solo desea tomar una entrada una vez, y podría almacenar las respuestas en una matriz de caracteres si así lo desea.

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

Me gusta lo siguiente:

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

y por ejemplo, haría:

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

Puede obtener la entrada del usuario usando Scanner. Puede utilizar la validación de entrada adecuada utilizando métodos adecuados para diferentes tipos de datos como next()for Stringo nextInt()for 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();

La forma más sencilla de obtener la entrada del usuario sería usar el escáner. Aquí hay un ejemplo de cómo se supone que debe usarse:

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 línea de código import java.util.Scanner;le dice al programa que el programador usará las entradas del usuario en su código. Como dice, importa la utilidad del escáner. Scanner sc=new Scanner(System.in);le dice al programa que inicie las entradas del usuario. Después de hacer eso, debe hacer una cadena o un entero sin un valor, luego ponerlos en la línea a=sc.nextInt();o a=sc.nextLine();. Esto le da a las variables el valor de las entradas del usuario. Entonces puedes usarlo en tu código. Espero que esto ayude.

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 entrada del teclado usando el escáner es posible, como han publicado otros. Pero en estos tiempos altamente gráficos no tiene sentido hacer una calculadora sin una interfaz gráfica de usuario (GUI).

En Java moderno, esto significa usar una herramienta de arrastrar y soltar JavaFX como Scene Builder para diseñar una GUI que se parezca a la consola de una calculadora. Tenga en cuenta que usar Scene Builder es intuitivamente fácil y no requiere ninguna habilidad adicional de Java para sus controladores de eventos que lo que ya puede tener.

Para la entrada del usuario, debe tener un TextField ancho en la parte superior de la consola GUI.

Aquí es donde el usuario ingresa los números en los que desea realizar funciones. Debajo de TextField, tendría una serie de botones de función que realizan funciones básicas (es decir, sumar / restar / multiplicar / dividir y memoria / recuperar / borrar). Una vez que se ha establecido la GUI, puede agregar las referencias de 'controlador' que vinculan cada función de botón a su implementación de Java, por ejemplo, una llamada al método en la clase de controlador de su proyecto.

Este video es un poco antiguo pero aún muestra lo fácil que es usar Scene Builder.