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.
|
|
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.
2
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.
3
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
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
4
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”);
}
}
5
ß
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.
6
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.
7
- 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.
8
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
}
{
// Aquí el código que puede fallar
}
catch (Exception e)
{
System.out.println (e);
e.printStackTrace ();
// Aquí el código para tratar el fallo
}
9
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);
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();
}
}
}
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();
}
}
}
10
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
$ 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)
$ 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());
11
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.
12
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 =
"";
13
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);
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);
}
}
}
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:
14
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);
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);
}
}
15
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:
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");
}
}
}
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");
}
}
}
16
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);
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
}
17
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
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 ();
} 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 {
if (source.hasNextInt()) {
System.out.println ("Has ingresado un int");
}
else {
System.out.println ("NO Has ingresado un int");
}
}
}
}
else {
System.out.println ("NO Has ingresado un int");
}
}
}
18
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
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");
}
20
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 ());
System.out.println (sl.next ());
System.out.println (sl.next ());
21
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 ());
System.out.println
(sl.next ());
}
s.close
();
} catch
(FileNotFoundException e) {
e.printStackTrace ();
}
}
}