Entrada de datos - Departamento de Computación

Entrada de datos
Desde teclado
1. Importar el paquete java.io
2. Crear un objeto BufferedReader, pasando como parámetro al constructor un objeto
InputStreamReader. Por ejemplo:
BufferedReader t = new BufferedReader(new InputStreamReader(System.in));
3. Usar el método String readLine()para leer el dato. El ingreso del dato desde teclado
debe finalizar con la tecla ENTER. Por ejemplo:
String s = t.readLine()
4. Si el valor leído desde teclado, se requiere almacenar en una variable de un tipo diferente a
String, se debe realizar la conversión de tipo utilizando algún método apropiado para ello.
Por ejemplo:
•
para leer un dato int
int x = Integer.parseInt(s.trim()); ó
int x = Integer.parseInt(t.readLine().trim());
•
para leer un dato double
double d = new Double(s).doubleValue(); ó
double d = new Double(t.readLine()).doubleValue(); ó
double d = Double.parseDouble(s.trim()); ó
double d = Double.parseDouble(t.readLine().trim());
•
para leer un dato char
char c = s.charAt(0); ó
char c = t.readLine().charAt(0);
2
Desde un archivo secuencial
1. Importar los paquetes java.io y java.util
2. Crear un objeto File. (Se recomienda revisar la clase File y observar todos los métodos
disponibles en ella, especialmente los constructores). Por ejemplo:
File f = new File("u:\\compAvanz12005\\unidad2\\datos.dat");
3. Crear un objeto BufferedReader, pasando como parámetro un objeto FileReader
BufferedReader arch = new BufferedReader(new FileReader(f));
4. Para leer un registro del archivo, usar el método
String readLine() throws IOException
El cual lee una línea de texto. Se considera, que una línea de texto finaliza con un line feed
('\n'), un carriage return ('\r') o un carriage return seguido inmediatamente por un linefeed
(ENTER). Por ejemplo:
String s = arch.readLine();
En la variable s estarán almacenados la secuencia de campos (tokens).
5. Crear un objeto StringTokenizer, pasando como parámetro la variable s leída en el
paso anterior. (Es recomendable revisar la clase StringTokenizer para conocer que
métodos contiene). Por ejemplo:
StringTokenizer st = new StringTokenizer(s);
6. Si el separador de campo, de los datos almacenados en el registro es un espacio en blanco o
un tabulador, o enter, extraer los datos contenidos en el registro usando el método
nextToken() de la clase StringTokenizer. Por ejemplo, si el registro tiene dos campos
de datos:
String dato1 = st.nextToken();
String dato2 = st.nextToken();
7. Si los valores dato1 y dato2, se requieren almacenar en variables de un tipo diferente a
String, se debe realizar la conversión de tipo utilizando algún método apropiado para ello.
Similar al paso 3 de la lectura desde teclado.
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2005.
3
Ejemplo
El siguiente método leer de la clase Elipse, lee desde un archivo de datos asociado al
objeto en, un registro que contiene dos valores int(x, y) y a continuación dos valores
double (a, b), correspondientes al centro (x,y) y semiejes (a,b) de un objeto Elipse
public void leer(BufferedReader en)throws EOFException, IOException{
String s;
StringTokenizer t;
s = en.readLine();
if (s == null) throw new EOFException("EOF encontrado");
t = new StringTokenizer(s);
x = Integer.parseInt(t.nextToken().trim());
y = Integer.parseInt(t.nextToken().trim());
a = java.lang.Double.parseDouble(t.nextToken().trim());
b = java.lang.Double.parseDouble(t.nextToken().trim());
}
El siguiente código abre un archivo Elipses.txt, y luego lee los datos almacenados en el
archivo. La primera línea del archivo, contiene un valor n que representa el número de
registros del archivo, y en las siguientes n líneas, se encuentran los cuatro valores
correspondientes a los datos de una Elipse.
File f1 = new File("u:\\compAvanz12005\\unidad2\\ Elipses.txt");
FileReader fS1 = new FileReader(f1);
BufferedReader entrada = new BufferedReader(fS1);
Elipse e = new Elipse(p,0,0);
n = Integer.parseInt(entrada.readLine().trim());
for (int i = 0; (i < n) ; i++){
e.leer(entrada);
// lee un registro del archivo
System.out.println(e);
// lo escribe en la consola
}
entrada.close(); // cierra el archivo
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2005.
4
Salida de datos
Hacia un archivo secuencial
1. Importar el paquete java.io
2. Crear un objeto File.
File f = new File("u:\\compAvanz12005\\unidad2\\datos.dat");
3. Crear un objeto BufferedWriter, pasando como parámetro al constructor un objeto
FileWriter. Ejemplo:
BufferedWriter bw= new BufferedWriter(new FileWriter(f));
4. Crear un objeto PrintWriter, pasando como parámetro el objeto BufferedWriter
PrintWriter salida = new PrintWriter(bw);
5. Usar el método println() para escribir un registro de datos y colocar la marca de fin de
registro (enter).
Por ejemplo:
salida.println((double)i/10 + "\t"+ 2*i+" "+i);
Ejemplo
El siguiente código, abre un archivo secuencial para escribir datos en él y luego escribe 10
registros
// escribe datos en un archivo de acceso secuencial
File f = new File("u:\\compAvanz12005\\unidad2\\datos.dat");
FileWriter fE = new FileWriter(f);
BufferedWriter bw= new BufferedWriter(fE);
PrintWriter salida = new PrintWriter(bw);
for (int i = 0; i<10; i++){
salida.println((double)i/10 + "\t"+ 2*i+" "+i);
}
salida.close(); // cierra el archivo
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2005.
5
Ir al inicio de un archivo
Para poder retornar al inicio de un archivo, una vez que este ha sido recorrido, previamente
debe haberse colocado una marca al inicio del archivo, cuando fue abierto, con el método
void
mark(int readAheadLimit)throws
IOException
(el parámetro es el numero de
caracteres de pueden ser leídos, preservando la marca, después que se leen esa cantidad de
caracteres puede fallar un intento de reset)
para luego poder retornar a la posición marcada con el método
void reset() throws IOException.
Por ejemplo:
public static void main(String[] args) throws Exception{
File f = new File("u:\\compAvanz22004\\unidad2\\geometria.dat");
BufferedReader arch = new BufferedReader(new FileReader(f));
arch.mark(1024); // marca el inicio del archivo
final int N = 10;
Punto p[] = new Punto[N];
for(int i = 0; i < N; i++){
// lee N registros
p[i]= new Punto();
p[i].leer(arch);
}
arch.reset(); // retorna
a la posición marcada con el metodo mark
Circulo p1[] = new Circulo[N];
for(int i = 0; i < N; i++){
// lee de Nuevo los N registros
p1[i]= new Circulo(0,0,0);
p1[i].leer(arch);
}
arch.close();
}
Universidad de Carabobo. Facultad de Ingeniería. Departamento de Computación. Computación Avanzada. 1-2005.