Estructura de Datos IS-241

Ingeniería de Sistemas - UNSCH

Archivos

Archivos de texto
Si se desea procesar datos de un archivo existente, se debe:
1. Abrir el archivo
2. Leer o introducir los datos en las variables, un elemento a la vez
3. Cerrar el archivo cuando se termine de trabajar con él
Para transferir algunos datos de ciertas variables a un archivo, se debe:
1. Abrir el archivo
2. Extraer o escribir los elementos en la secuencia requerida
3. Cerrar el archivo cuando se termine de trabajar con él

Al leer un archivo, todo lo que puede hacerse es leer el siguiente elemento. Si, por
ejemplo, quisiéramos examinar el último elemento, tendríamos que codificar un ciclo
para leer cada uno de los elementos en turno, hasta llegar al elemento requerido. Para
muchas tareas, es conveniente visualizar un archivo como una serie de líneas de texto,
cada una compuesta por un número de caracteres y que termina con el carácter de fin de
línea. Un beneficio de esta forma de trabajo es la facilidad de transferir archivos entre
aplicaciones. Así se podría crear un archivo ejecutando un programa en Java y después
cargarlo en un procesador de palabras, editor de texto o correo electrónico.

Las clases de flujo están organizadas de la siguiente forma:

Reader
BufferedReader
InputStreamReader
FileReader
Writer
PrintWriter
FileWriter

Para procesar archivos se utilizan las clases BufferedReader y PrintWriter para leer y
escribir líneas de texto, y para la entrada que no provenga de archivos (desde el teclado
y páginas Web) también se utiliza InputSreamReader.

Los programas que utilizan archivos deben contener la instrucción: import java.io.*;
"Búfer" significa que, el software lee un gran trozo de datos del dispositivo de
almacenamiento externo y lo guarda en la RAM, de tal forma que invocaciones
sucesivas de los métodos que necesitan leer una pequeña cantidad de datos del
dispositivo de almacenamiento de archivos puedan obtener rápidamente los datos de la
RAM. Por lo tanto, un búfer actúa como un amortiguador entre el dispositivo de
almacenamiento y el programa.
Escribir un archivo de texto requiere el uso apropiado de clases para crear el flujo de
salida y llamar a los métodos para escribir los datos. La clase FileWriter representa un
archivo texto de salida. La clase PrintWriter ofrece los métodos print y println similares
a los de System. Después de terminar de crear o utilizar un archivo es muy
recomendable que se cierre, ya que de lo contrario no se garantiza que los datos estarán
almacenados en un dispositivo semi-permanente.
Ejemplos;
El siguiente código crea un archivo e introduce datos.

Ing. Jennifer Rocío Pillaca De La Cruz Página 1

 Estructura de Datos IS-241
Ingeniería de Sistemas - UNSCH
public class CrearArchivo {
public static void main(String[] args) throws FileNotFoundException {
FileOutputStream fout = null;
try {
fout = new FileOutputStream("archivo.txt", true);
} catch (IOException ex) {
System.out.println("Error al crear el fichero");
System.out.println(ex.getMessage());
System.exit(1);
}
String[] arreglo = {"\nJennifer\n", "Maria\n", "Lina"};
for(int i = 0; i < arreglo.length; ++i) {
for( int j = 0; j < arreglo[i].length(); ++j ) {
try {
fout.write( (byte) ( arreglo[ i ].charAt( j ) ) );
} catch (IOException ex) {
System.out.println("Error escribiendo los datos");
System.exit(1);
}}}}}

El siguiente código lee el archivo anterior.

public class LeerArchivo {

public static void main(String[] args) {
try
{ FileInputStream fis = new FileInputStream("archivo.txt ");
for (int n = fis.read(); n != -1; n = fis.read())
{ System.out.write(n);//escribe en pantalla el dato
}
}
catch (IOException ex)
{ System.err.println(ex);
}
}
}

El siguiente código crea un archivo e introduce datos, mediante campos.

import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
Ing. Jennifer Rocío Pillaca De La Cruz Página 2
 Estructura de Datos IS-241
Ingeniería de Sistemas - UNSCH
import java.util.Scanner;

public class Escritura {

public static void main( String args[] )throws IOException{
Scanner leer = new Scanner(System.in);
DataOutputStream Archi = null;
int i;

String nombre=new String("");

int calif1;
int calif2;
int calif3;
double promedio;
try{
for (i=0; i<1; i++){
Archi = new DataOutputStream( new FileOutputStream("../Archivo1.dat",true) );
System.out.println("Escribe Nombre: ");
nombre = leer.next();
System.out.println("Ingrese Calificacion 1: ");
calif1 = leer.nextInt();
System.out.println("Ingrese Califiación 2");
calif2 = leer.nextInt();
System.out.println("Ingrese Calificacion 3");
calif3 = leer.nextInt();

Archi.writeUTF(nombre);
Archi.writeInt(calif1);
Archi.writeInt(calif2);
Archi.writeInt(calif3);
Archi.close();
}
}
catch(FileNotFoundException fnfe) {}
catch (IOException ioe) {}
}
}

El siguiente código lee el archivo anterior.

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class Lectura {
public static void main( String args[] )throws IOException{
DataInputStream Archi = null;
Ing. Jennifer Rocío Pillaca De La Cruz Página 3
 Estructura de Datos IS-241
Ingeniería de Sistemas - UNSCH
int matricula=0;
String nombre=new String("");
int calif1;
int calif2;
int calif3;
double promedio;
try{
Archi = new DataInputStream( new FileInputStream("../Archivo1.dat") );
while (true){
nombre = Archi.readUTF();
System.out.println("Nombre: "+nombre+" ");
calif1= Archi.readInt();
System.out.println("Calificacion 1: "+calif1+" ");
calif2= Archi.readInt();
System.out.println("Calificacion 2: "+calif2+" ");
calif3= Archi.readInt();
System.out.println("Calificacion 3: "+calif3+" ");
int suma = calif1 + calif2 + calif3;
promedio = suma/3;
System.out.println("El promedio es: "+promedio);
}
}
catch(FileNotFoundException fnfe) {}
catch (IOException ioe) {}
Archi.close();
}
}

Ing. Jennifer Rocío Pillaca De La Cruz Página 4