(JAVA)Entrada de datos. Lectura de datos por teclado en Java. Scanner y BufferedReader

Entrada de datos. Lectura de datos por teclado en Java. 
Scanner y BufferedReader

     La entrada o lectura de datos en Java es uno de los conceptos más importantes y fundamentales al momento de interactuar con el usuario de nuestro programa. La entrada de datos en Java, a diferencia de otros lenguajes es un poco complicada (no demasiado) y existen diferentes formas de hacerlo, unas más complejas que otras. En este artículo veremos dos maneras sencillas de leer datos para nuestro programa en Java, veremos entonces dos formas de leer datos del usuario por teclado. La primera usando las clases BufferedReader e InputStreamReaderambas de la librería java.io y la segunda con la clase Scanner de la librería java.util.

Entrada usando la clase BufferedReader y InputStreamReader.

package entradajava;

  import java.io.BufferedReader;

  import java.io.IOException;

  import java.io.InputStreamReader;

public class EntradaJava {

     public static void main(String[] args) throws IOException

    {

        //Notar que readLine() nos obliga a declarar IOException

        BufferedReader br;

        br = new BufferedReader(new InputStreamReader(System.in));   //Ya tenemos el "lector" 

        //Se pide un dato al usuario

        System.out.println("Por favor ingrese su nombre");

        //Se lee el nombre con readLine() que retorna un String con el dato

        String nombre = br.readLine(); 

        //Se pide otro dato al usuario

        System.out.println("Bienvenido " + nombre + ". Por favor ingrese su edad");

        //Se guarda la entrada (edad) en una variable

        String entrada = br.readLine(); 

        //Nótese que readLine siempre retorna String y la clase BufferedReader...

        //no tiene un método para leer enteros, así que debemos convertirlo.

        //Se transforma la entrada anterior en un entero

        int edad = Integer.parseInt(entrada);

         //Si el usuario ingresó solo números funcionará bien, de lo contrario

        //generará una excepción

         //Operacion numerica con la edad

        System.out.println("Gracias " + nombre + " en 10 años usted tendrá " + (edad + 10) + " años.");

    }

}

Entrada por teclado usando la Clase Scanner

package entradajava2;

   import java.util.Scanner;

public class EntradaJava2 {

     public static void main(String[] args)

    {

        //Se crea el lector

        Scanner sc = new Scanner(System.in); 

        //Se pide un dato al usuario

        System.out.println("Por favor ingrese su nombre");

        

        //Se lee el nombre con nextLine() que retorna un String con el dato

        String nombre = sc.nextLine(); 

        //Se pide otro dato al usuario

        System.out.println("Bienvenido " + nombre + ". Por favor ingrese su edad");

        //Se guarda la edad directamente con nextInt()

        int edad = sc.nextInt(); 

        //Nótese que ya no hubo necesidad de usar parseInt()

        //pues nextInt nos retorna un entero derectamente

        

        //Operacion numerica con la edad

        System.out.println("Gracias " + nombre + " en 10 años usted tendrá " + (edad + 10) + " años."); 

    }

}

(JAVA) acceso a los elementos de arrays bidimensionales

El acceso a los elementos de arrays bidimensionales sigue el mismo formato que el acceso a los
elementos de un array unidimensional. En este caso, con las matrices deben especificarse los índices de la fila y la columna.

El formato general para la asignación directa de valores a los elementos es:

inserción de elementos

  <nombre array>[indice fila][indice columna] = valor elemento;

extracción de elementos

  <variable> = <nombre array> [indice fila][indice columna];

Con dos bucles anidados se accede a todos los elementos de una matriz. Su sintaxis es:

int fila, col;
for (fila = 0; fila < NumFilas; ++fila)
  for (col = 0; col < NumCol; ++col)
    Procesar elemento Matriz[fila][col];

El número de filas y de columnas se puede obtener con el atributo length. Con este atributo, la sintaxis para acceder a los elementos es:

<tipo> Matriz[][] ;

<especificación de filas y columnas con operador new>

for (fila = 0; fila < Matriz.length; ++fila)
  for (col = 0; col < Matriz[fila].length; ++col)
    Procesar elemento Matriz[fila][col];

(JAVA) Inicialización de arrays multidimensionales

La inicialización se hace encerrando entre llaves la lista de constantes, separadas por comas, que forma cada fila, como en los ejemplos siguientes:

.   int tabla1[ ][ ] = { {51, 52, 53},{54, 55, 56} };

     Define una matriz de 2 filas por 3 columnas cada una.

     O bien con este formato más amigable:

     int tabla1[ ][ ] = {  {51, 52, 53},
                                    {54, 55, 56} };
2.  int tabla2[ ][ ] = {
                                  {1, 2, 3, 4},
                                  {5, 6, 7, 8},
                                  {9, 10, 11, 12}
                                };

                                                                 Tablas de dos dimensiones

EJEMPLOS
Declaración y creación de arrays bidimensionales de distinto número de elementos por fila.

1.   double tb[ ][ ] = { {1.5, -2.5}, {5.0, -0.0, 1.5} };
     Se ha definido una matriz de 2 filas, la primera con dos columnas y la segunda con 3.

2.    int[ ] a = {1,3,5};
     int[ ] b = {2,4,6,8,10};
     int mtb[ ][ ] = {a, b};

     Se ha definido el array a de 3 elementos, el b de 4 elementos y la matriz mtb de 2 filas, la primera con 3 elementos o columnas y la segunda con 5.

Java permite crear matrices de distintas formas.


NOTA:

En  un  array  bidimensional  tabla,  al  ser  un  array  de  arrays,  el  atributo  length  de tabla contiene el número de filas. El atributo length de cada array fila contiene el número de columnas.

  float ventas[ ][ ] = {
                                      {0.,0.,0.},        // 3 elementos
                                      {1.0.,1.0},       // 2 elementos
                                      {-1.0}              // 1 elemento
                                 };

  System.out.print(ventas.length);         // escribe 3
  System.out.print(ventas[0].length);    // escribe 3
  System.out.print(ventas[1].length);    // escribe 2
  System.out.print(ventas[2].length);    // escribe 1

Precaución
En la definición de un array bidimensional no es posible omitir el número de filas. Así, la declaración: 

double vt[ ][ ] = new double[ ][4]; 

es errónea ya que no se ha especificado el número de filas, y el tamaño queda indeterminado.

(JAVA) Arrays Multimensionales-Sintaxis-Declaración

 Los arrays multidimensionales son aquellos que tienen más de una dimensión y, en consecuencia, más de un índice. Los más usuales son los de dos dimensiones, conocidos también por el nombre de tablas o matrices. Sin embargo, es posible crear arrays de tantas dimensiones como requieran sus aplicaciones, ya sean tres, cuatro o más.
Un array de dos dimensiones (m × n) equivale a una tabla con múltiples filas y múltiples
columnas (Figura 3.2).

 El sistema de localizar un elemento es por las coordenadas representadas por su número de fila y su
número de columna (a,b).

 La sintaxis para la declaración de un array de dos dimensiones es:
<tipo de datoElemento> <nombre array> [ ][ ];

o bien

<tipo de datoElemento> [ ][ ]<nombre array>;

Ejemplos de declaración de matrices :
char pantalla[ ][ ];
int puestos[ ][ ];
double [ ][ ]matriz;

Estas  declaraciones  no  reservan  memoria  para  los  elementos  de  la  matriz,  realmente  son
referencias. Para reservar memoria y especificar el número de filas y de columnas se utiliza el
operador new. Así, a partir de las declaraciones anteriores:

pantalla  = new char[80][24]; // matriz con 80 filas y 24 columnas
puestos = new int[10][5];       // matriz de 10 filas por 5 columnas
final int N = 4;
matriz = new double[N][N];   // matriz cuadrada de N*N elementos

El operador new se puede aplicar a la vez que se hace la declaración. La sintaxis para definir 
una matriz es: 

<tipo de datoElemento> <nombre array>[ ][ ]=
    new <tipo de datoElemento> [<NúmeroDeFilas<] [<NúmeroDeColumnas>];

Atención:
Java requiere que cada dimensión esté encerrada entre corchetes. La sentencia:
int equipos[ ][ ] = new int[4,5] no es válida.

(JAVA) Arreglos-Declarar, leer, concatenar e imprimir un Arreglo de números

Arreglos-Declarar, leer, concatenar e imprimir un Arreglo de números usando JOptionPane


package javaapplication2;

import javax.swing.JOptionPane;

public class JavaApplication2 {

    public static void main(String[] args) {
     
        int [] calif=new int[100]; //Declaración del arreglo de 100 elementos
        int n=0;                            //Numero de elementos a procesar
     
        //JOptionPane.showInputDialog---> Pide dato y Devuelve una cadena
        //Integer.parseInt(string)--->Convierte una cadena numero a entero
        n = Integer.parseInt(JOptionPane.showInputDialog("Cuantas calificaciones"));
     
        //Ciclo para leer calificaciones y almacenarlos en el arreglo calif
        //la primera posición del arreglo esta en la posición 0(cero)
        //Cuando en un ciclo se ejecuta una sola instrucción no es necesario usar { }
        for(int i=0;i<n;i++)
            calif[i] = Integer.parseInt(JOptionPane.showInputDialog("Calificación "+(i+1) ));
     
        String cad="Calificaciones:";  //Variable para concatenar los números del arreglo
                                                        //notar que empieza con la cadena Calificaciones
        for(int i=0;i<n;i++)
        {
            cad=cad + " "+calif[i]+",";  //Se concatena cada calificación a la cadena
        }
     
        //Imprime la cadena obtenida
        JOptionPane.showMessageDialog(null, cad);      
    }
}

Ejemplo de ejecución del programa

JOptionPane y diálogos modales en Java Netbeans

En nuestras aplicaciones Java Swing es bastante habitual que tengamos que pedir al usuario la confirmación de una acción (por ejemplo, salir de la aplicación o borrar unos datos), pedirle algún dato sencillo, darle a elegir entre varias acciones o simplemente mostrarle un aviso. A veces es necesario para estas acciones abrir una ventana secundaria donde el usuario debe realizar la acción que sea y cerrarla. Por ejemplo, podemos mostrarle una ventana preguntando algo como "¿Estás seguro que quieres borrar todos esos datos?" y que tenga un par de botones "Sí",  "No".

Afortunadamente, en java no tenemos que hacer esas ventanas. Para las acciones más habituales, ya tenemos la clase JOptionPane que muestra esas ventanas por nosotros y nos devuelven la elección hecha por el usuario. En otras ocasiones, nos tendremos que hacer una ventana a nuestra medida, pero si usamos un JDialog modal, al menos tendremos la ventaja de que el código esperará a que el usuario introduzca los datos en dicha ventana.

Vamos a ver en este artículo ejemplos con JOptionPane y Diálogos modales. 

JOptionPane

JOptionPane tiene dos juegos repetidos de ventanas de aviso/confirmación. Una para ventanas normales y otra para JInternalFrame. Puesto que son lo mismo, vamos a ver aquí sólo los de ventanas normales. Las distintas posibilidades que tenemos de JOptionPane son:

JOptionPane.showOptionDialog()

Tenemos un método JOptionPane.showOptionDialog() que nos muestra la ventana más configurable de todas, en ella debemos definir todos los botones que lleva. De hecho, las demás ventanas disponibles con JOptionPane se construyen a partir de esta. Por ello, al método debemos pasarle muchos parámetros:

• parentComponent: A partir de este componente, se intentará determinar cual es la ventana que debe hacer de padre del JOptionPane. Se puede pasar null, pero conviene pasar, por ejemplo, el botón desde el cual se lanza la acción que provoca que se visualice el JOptionPane. De esta manera, la ventana de aviso se visualizará sobre el botón y no se podrá ir detrás del mismo si hacemos click en otro sitio.
• message: El mensaje a mostrar, habitualmente un String, aunque vale cualquier Object cuyo método toString() devuelva algo con sentido.
• title: El título para la ventana.
• optionType: Un entero indicando qué opciones queremos que tenga la ventana. Los posibles valores son las constantes definidas en JOptionPane: DEFAULT_OPTION, YES_NO_OPTION, YES_NO_CANCEL_OPTION, o OK_CANCEL_OPTION.
• messageType: Un entero para indicar qué tipo de mensaje estamos mostrando. Este tipo servirá para que se determine qué icono mostrar. Los posibles valores son constantes definidas enJOptionPane: ERROR_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE, QUESTION_MESSAGE, o PLAIN_MESSAGE
• icon: Un icono para mostrar. Si ponemos null, saldrá el icono adecuado según el parámetro messageType.
• options: Un array de objects que determinan las posibles opciones. Si los objetos son componentes visuales, aparecerán tal cual como opciones. Si son String, el JOptionPane pondrá tantos botones como String. Si son cualquier otra cosa, se les tratará como String llamando al método toString(). Si se pasa null, saldrán los botones por defecto que se hayan indicado en optionType.
• initialValue: Selección por defecto. Debe ser uno de los Object que hayamos pasado en el parámetro options. Se puede pasar null.

La llamada a JOptionPane.showOptionDialog() devuelve un entero que representa la opción que ha seleccionado el usuario. La primera de las opciones del array es la posición cero. Si se cierra la ventana con la cruz de la esquina superior derecha, el método devolverá -1.

Aquí un ejemplo de cómo llamar a este método

int seleccion = JOptionPane.showOptionDialog(    unComponentePadre,    "Seleccione opcion",    "Selector de opciones",    JOptionPane.YES_NO_CANCEL_OPTION,    JOptionPane.QUESTION_MESSAGE,    unIcono,    // null para icono por defecto.    new Object[] { "opcion 1", "opcion 2", "opcion 3" },   // null para YES, NO y CANCEL    "opcion 1"); if (seleccion != -1)    System.out.println("seleccionada opcion " + (seleccion + 1));

y la ventana que se obtiene con el código anterior

JOptionPane.showInputDialog()

Tenemos varios métodos JOptionPane.showInputDialog() y la diferencia entre ellos es que tienen más o menos parámetros, según queramos aceptar o no las opciones por defecto. Los parámetros y sus significados son muy similares a los del método showOptionDialog(), pero hay una diferencia.

Si usamos los métodos que no tienen array de opciones, la ventana mostrará una caja de texto para que el usuario escriba la opción que desee (un texto libre). Si usamos un método que tenga un array de opciones, entonces aparecerá en la ventana un JComboBox en vez de una caja de texto, donde estarán las opciones que hemos pasado.

Aquí un par de trozos de código, el primero para conseguir una caja de texto,

// Con caja de texto String seleccion = JOptionPane.showInputDialog(    unComponentePadre,    "Input dialog",    JOptionPane.QUESTION_MESSAGE);  // el icono sera un iterrogante              System.out.println("El usuario ha escrito "+seleccion);

y la imagen que obtenemos con este código

En este segundo ejemplo, damos todas las opciones que queremos, obteniendo un JComboBox

// Con JCombobox Object seleccion = JOptionPane.showInputDialog(    unComponentePadre,    "Seleccione opcion",    "Selector de opciones",    JOptionPane.QUESTION_MESSAGE,    unIcono,  // null para icono defecto    new Object[] { "opcion 1", "opcion 2", "opcion 3" },    "opcion 1");  System.out.println("El usuario ha elegido "+seleccion);

y esta es la imagen que se obtiene.

JOptionPane.showMessageDialog()

Esta es la más sencilla de todas, sólo muestra una ventana de aviso al usuario. La ejecución se detiene hasta que el usuario cierra la ventana. Hay varios métodos con el mismo nombre y más o menos parámetros, en función de si aceptamos las opciones por defecto (icono, por ejemplo) o queremos cambiar alguna cosa. Un trozo de código para llamarlo

JOptionPane.showMessageDialog(
   componentePadre,
   "Un aviso puñetero");

System.out.println("ya estas avisado");

y la imagen que muestra este código

JOptionPane.showConfirmDialog()

Este método muestra una ventana pidiendo una confirmación al usuario, estilo "¿Seguro que lo quieres borrar todo?" y da al usuario opción de aceptar o cancelar ese borrado masivo que está a punto de hacer. El método devuelve un entero indicando la respuesta del usuario. Los valores de ese entero puede ser alguna de las constantes definidas en JOptionPane: YES_OPTION, NO_OPTION, CANCEL_OPTION, OK_OPTION, CLOSED_OPTION. Por supuesto, hay metodos iguales con más o menos parámetros para configurar las cosas más o menos.

El siguiente ejemplo de codigo

int confirmado = JOptionPane.showConfirmDialog(
   componentePadre,
   "¿Lo confirmas?");

if (JOptionPane.OK_OPTION == confirmado)
   System.out.println("confirmado");
else
   System.out.println("vale... no borro nada...");

muestra la siguiente imagen