Introducción
Que por medio de estos comandos podemos leer varios tipos de ya sean
números,letras o bytes ya q cada letra o numero tiene su correspondiente n
bytes.
Que también existen también cadenas de textos y que también puede
cambiar un byte a barios tipos de carácter
Por lo cual es important saber para que sirve cada uno de estos
comandos para leer desde el teclado divrsos tipos de datos.
System.in
En java tenemos accesible el teclado desde System.in, que es un InputStream del que podemos leer bytes. Por ejemplo, podemos leer bytes del teclado de esta forma
En java tenemos accesible el teclado desde System.in, que es un InputStream del que podemos leer bytes. Por ejemplo, podemos leer bytes del teclado de esta forma
//
Lectura de un byte
int byte =
System.in.read();
// Lectura de hasta 10
bytes
byte [] buffer = new
byte[10];
System.in.read(byte);
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, correspodiente 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.
InputStreamReader y BufferedReader
Antes de java 1.5, 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:
InputStreamReaderisr = new
InputStreamReader(System.in);
BufferedReaderbr = new
BufferedReader (isr);
Con esto, podemos leer líneas completas usando el BufferedReaderbr.
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
intnumero = Integer.parseInt
(br.readLine());
y debemos, por supuesto, capturar la excpeción en
caso de que la cadena no se pueda convertir a String. En cualquier caso,
todo esto sigue siendo algo engorroso.
Scanner
Desde java 1.5 tenemos disponible para
facilitarnos toda esta tarea, 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);
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());
Y si ahora ponemos el programa completo
packagecom.chuidiang.ejemplos.file_scanner;
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.Scanner;
public class FileScanner {
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.useDelimiter("\\s*,\\s*");
System.out.println(sl.next());
System.out.println(sl.next());
System.out.println(sl.next());
}
s.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
Ejemplo de InputStreamReader y BufferedReader
Ejemplo
sencillo del uso de la clase BufferedReader y del Input Stream Reader, como
podemos apreciar nos guarda lo que typeamos con el teclado y lo utiliza a modo
que nos regresa la información.
2)Ejemplo
import
java.io.*;
public class main {
public static void main(String[] args) throws Exception{
String nombre;
InputStreamReadertexto;
BufferedReaderteclado;
texto= new InputStreamReader(System.in);
teclado = new BufferedReader(texto);
System.out.println("Dame tunombre: ");
nombre = teclado.readLine();
System.out.println(nombre);
}
}
public class main {
public static void main(String[] args) throws Exception{
String nombre;
InputStreamReadertexto;
BufferedReaderteclado;
texto= new InputStreamReader(System.in);
teclado = new BufferedReader(texto);
System.out.println("Dame tunombre: ");
nombre = teclado.readLine();
System.out.println(nombre);
}
}
1) Systemejemplo
#include <signal.h>
int system(const char *cmd)
{
int stat;
pid_tpid;
structsigactionsa, savintr,
savequit;
sigset_tsaveblock;
if (cmd == NULL)
return(1);
sa.sa_handler = SIG_IGN;
sigemptyset(&sa.sa_mask);
sa.sa_flags = 0;
sigemptyset(&savintr.sa_mask);
sigemptyset(&savequit.sa_mask);
sigaction(SIGINT, &sa, &savintr);
sigaction(SIGQUIT, &sa,
&savequit);
sigaddset(&sa.sa_mask,
SIGCHLD);
sigprocmask(SIG_BLOCK,
&sa.sa_mask, &saveblock);
if ((pid = fork()) == 0) {
sigaction(SIGINT,
&savintr, (structsigaction *)0);
sigaction(SIGQUIT,
&savequit, (structsigaction *)0);
sigprocmask(SIG_SETMASK,
&saveblock, (sigset_t *)0);
execl("/bin/sh",
"sh", "-c", cmd, (char *)0);
_exit(127);
}
if (pid == -1) {
stat = -1; /* errno comes
from fork() */
} else {
while (waitpid(pid,
&stat, 0) == -1) {
if (errno != EINTR){
stat = -1;
break;
}
}
}
sigaction(SIGINT,
&savintr, (structsigaction *)0);
sigaction(SIGQUIT,
&savequit, (structsigaction *)0);
sigprocmask(SIG_SETMASK,
&saveblock, (sigset_t *)0);
return(stat);
2)Ejemplo de
system
import java.io.*;
classCuentaCaracteres {
public static void
main(String args[]) throws IOException {
intcontador=0;
while(System.in.read()!='\n')
contador++;
System.out.println();
// Retorno de carro "gratuito"
System.out.println("Tecleados
"+contador+" caracteres.");
}
Conclusión
·
Que pormedio del escáner podemos leer dos procedimientos
pero siempre ordenadamente
·
Y que ay otras q convierten esos bytes a caracteres
dependiendo l tipo
·
Y que cada letra tiene su correpondiente en byte
