Cómo leer la entrada desde el teclado en JAVA: como leer la entrada desde el teclado en java

Manual de cómo leer la entrada desde el teclado en JAVA

Sin y con clase scanner (java.util.Scanner)

En programación se utilizan muchos tipos de datos en los cuales se mencionan alguno aquí. La utilización del escáner es para que un programa se desarrolle más.

30-9-2012

INTRODUCCION

El presente trabajo consta de temas muy importantes de java que se aplican en hacer programas ya sea de lo cotidiano que pasa en la vida o de las cosas que suceden a cada momento como del trabajo o de otras sucesiones.

Un lenguaje de programación es un lenguaje utilizado por las personas para comunicarle a una computadora, un algoritmo o descripción de la tarea que ha de realizar.

Los programas son una elaboración de un algoritmo escrito en un lenguaje específico para la comunicación con las computadoras.

Los programas más simples escritos en lenguajes imperativos

Suelen realizar tres tareas de forma secuencial: Entrada de datos, Procesamiento de los datos, Salida de resultados.

Objetivos generales

El objetivo de estos temas tan interesantes que los estudiantes le entiendan muy bien y estos sean una ayuda para prosperar más en los estudios de programación ya que estos temas son los que se miran más en clase.

El otro objetivo es que los estudiantes desarrollen su capacidad intelectual, y que lean este texto para tener mayor rendimiento en los estudios.

Cómo leer la entrada desde el teclado en java

En java para poder escribir se emplea el objeto System.out, pero para leer del teclado es necesario emplear System.in. Este objeto pertenece a la clase InputStream, esto significa que para leer tenemos que emplear sus métodos, el más básico es read, que permite leer un carácter:

Lectura de un byte desde el teclado en java

El problema de leer bytes, es que luego debemos convertirlos a lo que necesitemos. Por ejemplo, si tecleamos una letra A mayúscula, el byte leído es el 65, correspondiente a la A mayúscula en código ASCII. Si tecleamos un 3 y un 2, es decir, un 32, leeremos dos bytes 51 y 52, correspondientes a los caracteres ASCII del 3 y del 2, NO leeremos un 32.

// Lectura de un byte

int byte = System.in.read();

// Lectura de hasta 10 bytes

byte [] buffer = new byte[10];

System.in.read (byte);

Podemos explicar brevemente cada una de las partes de esta declaración:

Public

Esta palabra significa que el método puede utilizarse desde fuera de la clase. Pero... ¿tendría sentido escribir un método que no pudiera utilizarse fuera de la clase? Sí, cuando se trata de métodos auxiliares que serán utilizados desde otros métodos de la clase pero no queremos (por seguridad o por estética) que puedan ser "vistos" fuera de la clase.

Static

La palabra static significa que para utilizar este método no necesitamos declarar un objeto de la clase. Veremos que en general para utilizar una clase es necesario tener un objeto de dicha clase (una variable de ese tipo, dicho con otras palabras) como

Ocurría con el objeto líneas de la clase Vector, pero el método main es un método especial ya que es el punto de comienzo de la aplicación.

Void

Todos los métodos deben devolver un resultado de algún tipo. En la cabecera hay que indicar dicho tipo. Sin embargo algunos métodos, como este realmente no necesitan devolver ningún valor. En este caso se declaran como de tipo void.

String [] args

Los métodos pueden recibir argumentos, es decir valores que se le pasan como en el caso de las funciones matemáticas seno y coseno, que tienen como argumento el valor del que queremos calcular el seno o el coseno. En el caso de main este argumento es una lista (representada en Java por []) de cadenas de caracteres (String en Java). Estas cadenas de caracteres se utilizan para que el usuario pueda pasar información al programa al inicio.

El punto de entrada de un programa en Java es la función main:

Public static void main (String [] args)

{

Declaraciones y sentencias escritas en Java

}

En realidad, Java es un lenguaje de programación orientada a

Objetos y todo debe estar dentro de una clase, incluida la función

Main, tal como muestra el siguiente programa

Public class Mi Primer Programa

{

Public static void main (String args[])

{

System.out.println ("Mensaje por pantalla”);

}

ß Las llaves {} delimitan bloques en Java (Conjuntos de elementos de un programa).

ß La máquina virtual Java ejecuta el programa Invocando a la función main. Mostrar resultados con la función System.out.println La función System.out.println nos permite mostrar una línea

de texto en la pantalla cuando ejecutamos el programa:

int edad = 25;

System.out.println (“Tengo ” + edad + “ años”);

Final double pi = 3.1415927;

System.out.println(“Valor de PI = ” + pi);

ß En la función println se suele utilizar el operador + para

concatenar cadenas de caracteres.

ß Cualquier cosa en Java se puede convertir en una cadena.

Leer datos desde el teclado en Java

En Java, la realización de operaciones de entrada de datos no es Inmediata, por lo que utilizaremos una clase auxiliar que se

Encargará de realizar las operaciones necesarias:

b = TextIO.getByte (); // byte

s = TextIO.getShort (); // short

i = TextIO.getInt (); // int

k = TextIO.getLong (); // long

x = TextIO.getFloat (); // float

y = TextIO.getDouble (); // double

a = TextIO.getBoolean (); // Boolean

c = TextIO.getChar (); // char

s = TextIO.getln (); // String

Internamente, la implementación de la clase auxiliar TextIO

realiza algo similar a lo siguiente:

InputStreamReader input;

BufferedReader lector;

String cadena;

// Secuencia de bytes ® Secuencia de caracteres

input = new InputStreamReader(System.in);

// Secuencia de caracteres ® Secuencia de líneas

lector = new BufferedReader(input);

try {

Cadena = lector.readLine ();

} catch (Exception e) {

Cadena = "";

}

// Y ahora hacemos lo que queramos con la cadena

Cuando estudiemos el uso de ficheros en Java comprenderemos

exactamente qué es lo que se hace al leer datos desde el teclado.

LOS Input Stream: EL OBJETO System.in

Al igual que Java nos ofrece System.out para escribir en pantalla, tenemos System.in para leer de ella. System.in es un objeto de una clase de java que se llama InputStream.

Para java, un InputStream es cualquier cosa de la que se leen bytes. Puede ser el teclado, un fichero, un socket, o cualquier otro dispositivo de entrada. Esto, por un lado es una ventaja. Si todas esas cosas son InputStream, podemos hacer código que lea de ellas sin saber qué estamos leyendo.

Por otro lado, es una pega. Como un InputStream es para leer bytes, sólo tiene métodos para leer bytes. Nosotros queremos leer palabras o números del teclado, no bytes. Si escribimos en el teclado una A mayúscula y la leemos con System.in, obtendremos un entero de valor 65, que es el valor del byte correspondiente a la A.

LOS Reader

Reader es una clase que lee caracteres. Esto se parece más a lo que queremos. Un Reader tiene métodos para leer caracteres. Con esta clase ya podríamos trabajar. La pena es que seguimos teniendo System.in, que es un InputStream y no un Reader.

¿Cómo convertimos el System.in en Reader?. Hay una clase en java, la InputStreamReader, que nos hace esta conversión. Para obtener un Reader, únicamente tenemos que instanciar un InputStreamReader pasándole en el constructor un InputStream.

El código es el siguiente

InputStreamReader isr = new InputStreamReader(System.in);

Estamos declarando una variable "isr" de tipo InputStreamReader. Creamos un objeto de esta clase haciendo new InputStreamReader (...). Entre paréntesis le pasamos el InputStream que queremos convertir a Reader, en este caso, el System.in

Tenemos el Reader. ¿Cómo funciona exactamente?

InputStreamReader es un Reader. Se comporta igual que in Reader y se puede poner en cualquier sitio que admita un Reader. Es decir, podemos leer de él caracteres.

Al construirlo le hemos pasado un InputStream, en concreto, System.in. InputStreamReader de alguna forma se lo guarda dentro.
Cuando a InputStreamReader le pedimos caracteres, él le pide al InputStream que tiene guardado dentro los bytes, los convierte a caracteres y nos los devuelve.

LA CLASE BufferedReader

InputStreamReader podríamos apañarnos. La pega es que nos da los caracteres sueltos. Si estamos leyendo de teclado, el que usa el programa puede escribir 10 caracteres o 20 o 13. Si usamos InputStreamReader, como lee caracteres sueltos, Tenemos que decirle cuántos queremos (que no lo sabemos), o bien ir pidiendo de uno en uno hasta que no haya más.

Se llama BufferedReader. El mecanismo para obtener un BufferedReader a partir de otro Reader cualquiera (por ejemplo el InputStreamReader), es similar al que usamos antes. Lo instanciamos pasándole en el constructor el Reader. El código es

BufferedReader br = new BufferedReader (isr);

El funcionamiento de esta clase es igual que el InputStreamReader. Cuando le pedimos una línea completa de caracteres (un String), ella se lo pide al Reader que tenga dentro, los convierte en String y nos lo devuelve.

Para pedirle un String, se usa el método readLine(). Este método lee todos los caracteres tecleados (recibidos si fuera otro dispositivo de entrada) hasta que encuentra la pulsación de la tecla <INTRO>, <RETURN> o como quieras llamarla.

String texto = br.readLine();

Esto lee del teclado un String completo y lo guarda en una variable "texto".

CONVERTIR LA CADENA String EN UN ENTERO int

Si queremos leer un número del teclado, el usuario escribe por ejemplo 123, con la clase BufferedReader obtendremos un String que contiene "123", es decir, tres caracteres. Eso no se parece en nada a un número 123.

Para convertir el String en un número entero (sin decimales), podemos usar otra clase de Java. La clase Integer vale para muchas cosas, pero entre otras es capaz de convertir un String a int. Siempre que sea posible. Por ejemplo "abc" no se puede convertir a número de ninguna manera.

La clase Integer es muy estricta. Para convertir el String a int necesita que el String sea exactamente un int. Cualquier caracter o letra que tenga el String y no valga, hará que la conversión falle. Por ejemplo, "123a" da fallo por culpa de la "a" del final. Del mismo modo "12 3" da fallo por el espacio entre el "12" y el "3". Bueno, esto en realidad creo que era así de estricto en versiones algo anteriores de java. Las actuales simplemente ignoran lo que va detrás del número.

La conversión se realiza así

Int valor = Integer.parseInt(texto);

Esto intenta convertir texto en un int y si no hay problemas, guarda el resultado en una variable int llamada valor.

EXCEPCIONES Exception Y try-catch

Cuando en java puede fallar algo, por ejemplo, la conversión de la cadena en int, suele avisarnos. Esto lo hace "lanzando excepciones". Una excepción es algo que lanza Java para avisarnos que ha habido un problema.

En nuestro código podemos "capturar" esas excepciones y hacer algo para tratar de arreglarlo. Por ejemplo, si le pedimos al usuario que meta un número, el usuario escribe "abc", lo leemos e intentamos convertirlo a int, nos salta una excepción. Si capturamos esa excepción, en el código que hagamos para tratarla, podemos avisar al usuario que se ha equivocado un poco al teclear, que lo intente de nuevo y volver a pedirle el número.

Para capturar una excepción, tenemos que hacer el código así

Try
{
    // Aquí el código que puede fallar
}
catch (Exception e)
{
    System.out.println (e);
    e.printStackTrace ();
    // Aquí el código para tratar el fallo
}

Lo habitual, al menos mientras estamos haciendo nuestro programa, es sacar por pantalla el error, para tener una pista de qué ha fallado. Eso se puede consiguir de las dos formas que he puesto arriba (y otras muchas)

Por un lado, de la forma que ya conocemos, con System.out.println (e); Esto nos saca una línea de texto con el error correspondiente en inglés del bueno.

Por otro lado, llamando al método printStackTrace () de la excepción que se ha provocado. Esta llamada escribe la misma línea de texto de error, pero además nos dice exactamente en qué línea de código se produce el error. Esta información es muy útil si nuestro programa todavía está a medias y no acaba de hacer lo que queremos.

UN EJEMPLO: SUMAR DOS NÚMEROS

Como ejemplo, vamos a ver un programa completo que pide dos números al usuario, los suma y saca el resultado. El ejemplo es este

import java.io.*;
public class suma
{ public static void main (String [] args)
{InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader (isr);

try {System.out.print("Sumando 1 : ");
            int s1 = Integer.parseInt(br.readLine());
            System.out.print("Sumando 2 : ");
            int s2 = Integer.parseInt(br.readLine());
            int suma=s1+s2;
    System.out.println ("La suma es " + s1 + "+" + s2 +"="+ suma);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

Cuando vimos el tema de paquetes, vimos que las clases se pueden agrupar en paquetes. Todas las clases que hemos visto aquí de java relativas a Streams y Readers, están en el paquete java.io. En la primera linea de código, con el import, estamos avisando a java que vamos a usar clases de ese paquete. Es necesario poner esta linea, decirle a java en qué paquetes están las clases, porque en otros paquetes puede haber clases con el mismo nombre, para distinguir unas de otras.

Para verlo funcionando, edita un fichero nuevo que se llame suma.java, copia todo este texto y sálvalo.

Luego lo compilas y lo puedes ejecutar

$ javac suma.java
$ java suma
Sumando 1 : 2
Sumando 2 : 4
La suma es 2+4=6

Si metemos la pata a posta, tendremos esto

$ javac suma.java
$ java suma
Sumando 1 : 2
Sumando 2 : asd
java.lang.NumberFormatException: For input string: "asd"
        at java.lang.NumberFormatException.forInputString(Unknown Source)
        at java.lang.Integer.parseInt(Unknown Source)
        at java.lang.Integer.parseInt(Unknown Source)
        at suma.main(suma.java:14)

Si sabemos un poco de inglés, vemos que obtenemos una excepción "NumberFormatException" para la cadena "asd", es decir, que no puede obtener el número a partir de "asd". En la última línea, vemos que el error se produce en la línea 14 del fichero suma.java, en el método main(). Es decir, si contamos líneas en el código, en la línea

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

Las otras tres líneas son en las clases de java que se ha producido el error. Normalmente no nos aportan demasiada información

la forma de leer más fácilmente cosas que no sean bytes (leer cadenas de texto o números), era usar las clases InputStreamReader y BufferedReader conjuntamente. La primera es capaz de convertir esos bytes a caracteres. La segunda es capaz de leer hasta un fin de línea. La forma de instanciar estas clases para usarlas con System.in es la siguiente:

InputStreamReader isr = new InputStreamReader (System.in);

BufferedReader br = new BufferedReader (isr);

Con esto, podemos leer líneas completas usando el BufferedReader br. Así, por ejemplo, si escribimos una A, con String cadena = br.readLine ();

Obtendremos en cadena una "A".

Sin embargo, seguimos necesitando hacer la conversión si queremos leer números. Por ejemplo, si escribimos un entero 32, en cadena obtendremos "32". La conversión se haría con

Int numero = Integer.parseInt (br.readLine ());

y debemos, por supuesto, capturar la excepción en caso de que la cadena no se pueda convertir a String. En cualquier caso, todo esto sigue siendo algo engorroso.

Como Leer la entrada desde el teclado en Java

Mediante un ejemplo sencillo vamos a explicar cómo podemos leer las entradas en Java, es decir, todo lo que introducimos mediante el teclado. Para esto utilizaremos dos clases contenidas en el paquete de entrada/salida de java (java.io), estas clases son: InputStreamReader y BufferedReader, además del flujo de entrada System.in.

Nada más para recordar cómo se manejan los flujos de datos en Java:

System – es el nombre de la clase estándar que contiene objetos que encapsulan las entradas y salidas (I/O) de nuestro sistema (entrada – todo lo que introducimos mediante el teclado, salida - lo que se despliega en la pantalla). Esta clase forma parte del paquete java.lang, por ello siempre está disponible.

in – representa la entrada estándar, lo que introducimos mediante el teclado. Esta clase es miembro de la clase System.

Después de un poco de teoría, veamos cómo sería el código.

1.- Primero tenemos que importar el paquete io de java de la siguiente manera:

Import java.io.*;

2.- Construimos un método para la lectura de entradas de tipo String, en este método utilizaremos las clases InputStreamReader y BufferedReader, además del objeto System.in para leer las entradas:

Public static String leerEntrada() {

String salida = "";

try{

// Definimos un flujo de caracteres de entrada: leerEntrada

BufferedReader leerEntrada = new BufferedReader(new InputStreamReader(System.in));

// Leemos la entrada, finaliza al pulsar la tecla Entrar

salida = leerEntrada.readLine();

} catch( IOException e) {

System.err.println ("Error: " + e.getMessage ());

}

return salida; // Devuelve el dato tecleado

}

Si construiremos nuestra clase e integramos el método main () nos quedaría de esta manera:

import java.io.*;

public class LeerEntrada {

public static String leerEntrada() {

String salida = "";

try{

// Definimos un flujo de caracteres de entrada: leerEntrada

BufferedReader leerEntrada = new BufferedReader (new InputStreamReader (System.in));

// Leemos la entrada, finaliza al pulsar la tecla Entrar

Salida = leerEntrada.readLine ();

} Catch (IOException e) {

System.out.println ("Error: " + e.getMessage ());

}

Return salida; // Devuelve el dato tecleado

}

Public static void main(String args[]){

String algo = "";

LeerEntrada leerEntrada = new LeerEntrada();

System.out.println ("Escribe algo: ");

algo = leerEntrada.leerEntrada();

System.out.println (algo);

}

Después compilamos la clase para crear el .class y finalmente la ejecutamos mediante el intérprete de java de la siguiente manera:

Java LeerEntrada La salida deberá ser algo parecido a esto:

Escribe algo: escribimos algo

Escribimos algo

Lectura por teclado en JAVA

Lectura de datos por teclado en java

Un ejemplo muy sencillo

Programa que pide tu nombre y lo imprime en pantalla:

import java.io.*;
class lectura {
public static void main(String[]args)throws IOException {
BufferedReader lectura = new BufferedReader(new InputStreamReader(System.in));
String nombre;
System.out.println("Ingrese su nombre: ");
nombre = lectura.readLine();
System.out.println("Bienvenido "+nombre);

}
}

Char caracter = (char) System.in.read ();

Pero como podemos comprobar es muy incómodo leer de letra en letra, por ello para poder leer una línea completa emplearemos el siguiente código:

BufferedReader lectura = new BufferedReader (new InputStreamReader (System.in));

En el cuál creamos un InputStreamReader a partir de System.in y pasamos dicho InputStreamReader al constructor de BufferedReader, el resultado es que las lecturas que hagamos sobre lectura son en realidad realizadas sobre System.in, pero con la ventaja de que se permite leer una línea completa.

Es necesario realizar un import de java.io para poder emplear esta lectura de líneas.

Programa Lectura de numeros por teclado en JAVA:

Al igual que en C# es necesario convertir el dato a integer:

import java.io.*;
class lectura {
public static void main(String[]args)throws IOException {
BufferedReader lectura = new BufferedReader(new InputStreamReader(System.in));
int num;
System.out.println("Ingrese numero: ");
num = Integer.parseInt(lectura.readLine());
System.out.println("su numero es "+num);

}

Integer.parseInt: Método que convierte un string (cadena de caracteres) en un dato numérico de tipo int.
Integer: Clase estándar que no necesita ser instanciada (está disponible por defecto).
y un último ejemplo:

import java.io.*;
public class ejercicio {
public static void main(String[] args)throws IOException {
BufferedReader lee = new BufferedReader(new InputStreamReader(System.in));
String nombre;
String apellido;
int edad;
System.out.println("Ingrese su nombre:");
nombre = lee.readLine();
System.out.println("Ingrese su apellido:");
apellido = lee.readLine();
System.out.println("Ingrese su edad:");
edad = Integer.parseInt(lee.readLine());
System.out.println("Su nombre es:"+nombre);
System.out.println("Su apellido es:"+apellido);
System.out.println("Su edad es:"+edad);
if (edad >=18){
System.out.println("Usted es mayor de edad");
}
else {
System.out.println("Usted no es mayor de edad");
}
}
}

Utilización del Scanner Import java.util.Scanner; Para leer de teclado se debe utilizar un objeto de la clase Scanner. Esta clase no es de las incluidas de forma automática y por eso debe incluirse mediante la palabra clave import. Si la clase está definida en otro paquete se escribe el nombre "cualificado", precedido por el nombre del paquete. En este caso la clase Scanner es parte del paquete útil que es a su vez parte de la clase java. Si se desean incluir varias clases se incluirán varias sentencias import:

Import java.util.Scanner;

Import java.util.Vector;

Si se quieren incluir varias (o todas) clases del mismo paquete se puede usar el símbolo *:

Import Java. Útil.*; // importa Scanner, Vector y muchas más

Para ver qué clases contiene cada paquete conviene consultar la ayuda de Java.

Scanner sc = new Scanner (System.in);

Esta instrucción declara e inicializa un objeto sc de tipo Scanner. En los capítulos posteriores veremos los objetos en detalle, pero aquí tenemos un primer ejemplo de cómo se crea un objeto mediante new. El parámetro System.in indica de dónde se leerá, en este caso de la entrada estándar pero igualmente se podría leer, por ejemplo de un fichero de texto de nombre "datos.txt":

Scanner sc = new Scanner (new File ("datos.txt"));

Int edad = sc.nextInt ( );

La llamada al método nextInt (); devuelve el siguiente entero que se puede leer del objeto de tipo Scanner. Además de enteros se pueden leer valores de otros tipos. Para leer una línea completa se usará el método nextLine (); que devuelve un valor de tipo String:

Import java.util.Scanner;

Public class Principal {

Public static void main (String [] args) {

Scanner sc = new Scanner (System.in);

System.out.print ("¿Cómo te llamas? ");

String nombre = sc.nextLine (); // leer una cadena de caracteres

System.out.println ("Es un placer conocerte "+nombre);

} // main

}

La utilización de la clase Scanner es muy sencilla. Lo primero que tenemos que hacer es declarar un objetivo Scanner instanciándolo contra la consola, es decir, contra el objeto System.in

Scanner reader = new Scanner (System.in);

Ahora, para leer lo que el usuario está introduciendo por la consola deberemos de utilizar el método .next. Este nos devolverá los caracteres que encuentre en la consola hasta encontrarse un retorno de carro y salto de línea. El valor se lo asignaremos a una variable String.

String sTexto = reader.next ();

Para complicar un poco nuestro ejemplo, vamos a hacer eco de las palabras recibidas hasta que el usuario teclee "FIN". Es por ello que utilizamos un bucle do-while. El código nos quedará de la siguiente forma:

do {

STexto = reader.next ();

System.out.println (sTexto);

} While (!sTexto.equals ("FIN"));

Importante es que te acuerdes que es necesaria la clase java.util para que todo funcione. Así al principio del programa incluiremos:

Import java.util.Scanner;

Usar Scanner para leer entrada de datos en java

Sé que se puede usar la clase Scanner para leer una entrada desde la línea de comandos (consola). Se hace de la siguiente manera (ejemplo para leer números tipo int):

Import java.util.Scanner;

Public class Main {

Public static void main(String[] args) {

System.out.println ("Ingresa numero tipo int");
Scanner source = new Scanner (System.in);

if (source.hasNextInt()) {

  System.out.println ("Has ingresado un int");
  }
  else {
  System.out.println ("NO Has ingresado un int");
  }
}
}

la clase Scanner. Basta instanciar esta clase pasándole el System.in y a partir de ahí tememos muchos métodos para obtener exactamente lo que queremos. Por ejemplo, podemos leer la A así :

Scanner sc = new Scanner (System.in);

String cadena = sc.nextLine ();

o bien, para obtener el 32, con

int entero = sc.nextInt();

Esta clase es bastante potente, por las siguientes características:

• Tiene varios constructores que admiten, además de System.in, cosas como secuencias de bytes o ficheros. Esto nos permite leer, por ejemplo, ficheros de forma más cómoda.

• Los métodos nextInt() admiten un entero radix, con lo que podríamos leer números en hexadecimal. Por ejemplo, si tecleamos FF y hacemos la lectura con radix 16, obtendríamos un 255.

// Lectura de un número en hexadecimal.

int entero = sc.nextInt(16);

• Admite Expresiones Regulares en Java como patrones de búsqueda, por lo que podemos leer trozos de línea directamente usando los separadores que queramos o buscando expresiones concretas. Por ejemplo, si introducimos 11:33:44, usando el siguiente código obtendremos los número 11, 33 y 44

Scanner sc = new Scanner (System.in);

// Usamos como delimitador el dos puntos, o bien cualquier

// Espacio/fin de línea (el \\s)

sc.useDelimiter ("[:\\s]");

// Leemos los tres enteros

Int a = sc.nextInt ();

Int b = sc.nextInt ();

Int c = sc.nextInt ();

// Obtendremos 11-33-44 de salida.

System.out.println (a +"-"+ b +"-"+ c);

19 Java – Clase java.util.Scanner – Lectura de entrada estándar (teclado) Ejemplo

/**

 * ScanStdin.java

 * Ejemplo de la lectura de la entrada estándar utilizando la clase java.util.Scanner, se realizan

 * algunas operaciones aritméticas sencillas con los valores introducidos por el usuario.

*/

Import java.io.IOException;

Import java.util.InputMismatchException;

Import java.util.Scanner;

/**

 * @author Dark[byte]

*/

Class ScanStdin {

    Private static Scanner sc;

/**

     * Punto de entrada del programa.

     * Se construyen los recursos necesarios para leer desde la entrada estándar, se muestra

     * el menú de opciones y se inicia el bucle del programa.

     * @Param args argumentos de la línea de comandos.

     * @Throws IOException si hay un fallo en la entrada\salida del flujo de datos.

*/

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

        sc = new Scanner(System.in);

        menú();

        Loop ();

/**

     * Muestra el menú de opciones

*/

    Private static void menu() {

        System.out.println ("-------------------------\n"

                + "Elige una opcion:\n"

                + "[a]- SUMAR\n"

                + "[b]- RESTAR\n"

                + "[c]- MULTIPLICAR\n"

                + "[d]- DIVIDIR\n"

                + "-\n"

                + "[m]- Muestra este menu\n"

                + "[x]- Sale del programa\n");

Ejemplo de lectura de un fichero con Scanner

Supongamos que tenemos un fichero en el que en cada línea hay los datos de una persona. Pueden ser un id, un nombre y una edad, separados por comas y quizás espacios. Algo como lo siguiente

1, Pedro , 33

2, Juan, 44

4, Antonio, 55

Vamos a hacer y explicar un pequeño programa en java usando Scanner que nos permita leer estos datos.

En primer lugar, creamos un File con el contenido del fichero y después una instancia de Scanner pasándole ese File. Por supuesto, al terminar de leer nuestro fichero, debemos cerrarlo

File f = new File("fichero.txt");

Scanner s;

try {

s = new Scanner(f);

// Aquí la lectura del fichero

s.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

}

Para la lectura del fichero, bastará de momento con un bucle para ir leyendo línea a línea. Para ello, podemos usar el método hasNextLine() que nos indica si hay o no una línea más que leer, y el método nextLine() que nos la devuelve

while (s.hasNextLine()) {

String linea = s.nextLine ();

// Aquí el tratamiento de la línea

}

Para tratar la línea y sacar los tres campos que hay en ella, podemos usar nuevamente otra instancia de la clase Scanner. El delimitador para los campos será una coma, precedida o no de uno o más espacios y seguida o no de uno o más espacios. Eso, usando Expresiones Regulares en Java se expresa así "\\s*,\\s*", donde \\s indica un espacio blanco y con asterisco detrás \\s* indica cero o más espacios en blanco. Por tanto, el código para recoger los tres campos, puede ser como este

Scanner sl = new Scanner (linea);

sl.useDelimiter ("\\s*,\\s*");

System.out.println (sl.next ());

Y si ahora ponemos el programa completo

Package com.chuidiang.ejemplos.file_scanner;

Import java.io.File;

Import java.io.FileNotFoundException;

Import java.util.Scanner;

Public class File Scanner {

Public static void main (String [] args) {

File f = new File ("fichero.txt");

Scanner s;

Try {

s = new Scanner(f);

While (s.hasNextLine ()) {

String linea = s.nextLine ();

Scanner sl = new Scanner (linea);

Sl.use Delimiter ("\\s*,\\s*");

System.out.println (sl.next());

System.out.println (sl.next ());

}

s.close ();

} catch (FileNotFoundException e) {

e.printStackTrace ();

}

domingo, 30 de septiembre de 2012

como leer la entrada desde el teclado en java

LOS Reader

LA CLASE BufferedReader

CONVERTIR LA CADENA String EN UN ENTERO int

EXCEPCIONES Exception Y try-catch

UN EJEMPLO: SUMAR DOS NÚMEROS

Lectura por teclado en JAVA

19

Java – Clase java.util.Scanner – Lectura de entrada estándar (teclado) Ejemplo

1 comentario:

Datos personales