Java: Entrada de datos por teclado

Arrojando algo de luz sobre mis dudas sobre la entrada por teclado en java, he dado con dos buenas formas de leer datos. La primera es la forma de recuperar los datos que el usuario teclee cuando invoca al programa desde la línea de comandos. Esto puede ser útil para ofrecerle algunos parámetros. La segunda manera es la típica entrada de teclado dentro de la ejecución del programa. Veámoslos por separado.

Recuperar parámetros al invocar el programa
Supongamos que desde la terminal quiero invocar a un programa que calcule el producto de dos números directamente escritos junto al nombre del programa, por ejemplo:
$ java Multiplicar 20 12
Lo interesante sería crear un programa que recuperase esos dos números y escribiese en pantalla su producto. Como este post se centra en la entrada, la salida será extremadamente simple. Lo haremos asi:
Primero creamos la estructura básica del programa:
class Multiplicar {
  public static void main (String[] args){
  }
}

Donde es obvio que habrá que multiplicar unos números enteros x e y:
class Multiplicar {
  public static void main (String[] args){
    System.out.println (x*y);
  }
}

Fijémonos por un momento en la firma del método main. La parte (String[] args) es la referida a recuperar el array de strings argumento de este método. El array de strings es lo que sigue al nombre del programa cuando lo invocamos (pudiendo ser uno o varios strings) asi que tan solo debemos establecer nuestros enteros x e y de acuerdo con sus posiciones en la linea de comandos.
class Multiplicar {
  public static void main (String[] args){
    int x = args[0];
    int y = args[1];
    System.out.println (x*y);
  }
}

Como vemos, el valor de x será el del primer numero que hayamos escrito y el de y, el segundo (recordemos que la numeración en los arrays empieza en cero). Sin embargo hay un pequeño problema a la hora de compilar, y es que los argumentos que sean numeros enteros (y en general, tipos de datos primitivos) deben ser envueltos. En nuestro caso, envolveremos los “int” en “Integer” con el método “parseInt”:
class Multiplicar {
  public static void main (String[] args){
    Integer x = Integer.parseInt(args[0]);
    Integer y = Integer.parseInt(args[1]);
    System.out.println (x*y);
  }
}

Compilamos con:
$ javac Multiplicar.java
Y ejecutamos, por ejemplo para multiplicar 20 por 12, con:
$ java Multiplicar 20 12
Si no ponemos parámetros, el programa arrojará un error en tiempo de ejecución.
Tratar los parámetros cómo un array de strings (donde cada string es un parámetro) no es algo único de Java. En C ocurre algo muy similar, prácticamente idéntico.

Un ejemplo más o menos similar que lee un nombre y muestra un saludo:
public class LeeNombreArgumento{
  public static void main (String[] args){
    String nombre = args[0];
    System.out.println ("Hola "+nombre);
  }
}

Leer datos durante la ejecución del programa
Esta es la entrada de datos más común que podemos encontrar, y su realización es un poco más laboriosa de lo que uno se espera de un lenguaje de alto nivel como Java.
En primer lugar, debemos entender que Java trata la entrada de datos como un flujo contenido en “System.in”. Para capturar este flujo, podemos utilizar un objeto “InputStream” y, sobre este, emplear otro objeto “BufferedStream”, que será el que convierta el flujo de datos en un flujo de caracteres. En una línea, todo esto queda:
BufferedReader inp = new BufferedReader (new InputStreamReader (System.in));
Ahora, siempre que queramos leer un dato, lo leeremos en el objeto “inp”.
Todos estos mecanismos requieren importar las librerias “java.io”, con lo cual, un programa que quiera mostrar un saludo será algo como lo siguiente:

import java.io.*;

public class Saluda{

  public static void main (String [] args){
    BufferedReader inp = new BufferedReader (new InputStreamReader (System.in));
    String nombre = "";
    System.out.print("Nombre: ");
    try{
      nombre = inp.readLine();
      System.out.println("Hola " + nombre);
    }catch (IOException e){
      System.out.println("Error");
    }
  }

}

Fíjate tambien en que por si acaso hubiese un error en la lectura (realizada por supuesto con un método readLine() sobre el objeto “inp”), hemos incrustado la lectura en medio de una secuencia try-catch que nos permitirá superponernos a una hipotética excepción de E/S.

Anuncios

Un comentario sobre “Java: Entrada de datos por teclado

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s