CURSO PROGRAMACIÓN II

UNIVERSIDAD DE CÓRDOBA
IV SEMESTRE

ARCHIVOS

Las diferentes estructuras de datos estudiadas hasta el momento trabajan con la

información almacenada en la memoria principal de la computadora. Esta
situación en ocasiones resulta tediosa porque después de ejecutar el programa y
cerrarlo, o apagar el computador la información almacenada en la memoria
principal se pierde.

El uso de archivos es una alternativa para guardar la información en la memoria

secundaria (disco duro, entre otros) cuando se quiere trabajar con programas que
ocupan mucho espacio en memoria, o para mantener a información después de
cada ejecución.

 Definición de archivo:

Un archivo es una secuencia de bits almacenados en la memoria secundaria,

como puede ser el disco duro; y son utilizados por las aplicaciones para su
funcionamiento. El Sistema Operativo de la computadora es el encargado de la
gestión de todos los archivos del sistema.

Entre los atributos o características que identifican a un archivo en el sistema,

están: el nombre, una extensión que estaría asociada al formato del archivo, el
tamaño, la ubicación, un identificador único en el sistema, entre otros.

La mayoría de lenguajes de programación como C++, PHP, Java, entre otros;

proporcionan librerías, clases o métodos que facilitan la manipulación de archivos
de texto y binarios. Permitiendo abrir el archivo para realizar operaciones de
entrada (lectura) o salida (escritura).

 Implementación de archivos en java:

Para la implementación de archivos en java se hace uso de clases definidas por el

lenguaje para realizar las operaciones de lectura o escritura sobre el archivo. Lo
primero que se debe hacer es importar las diferentes clases que se quieren utilizar
para la manipulación de archivos, por ejemplo:

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 CURSO PROGRAMACIÓN II
UNIVERSIDAD DE CÓRDOBA
IV SEMESTRE

Entonces si se quiere escribir o guardar información en el fichero plano se deben

utilizar las siguientes clases:

Nombre de la Clase Descripción

Proporciona información sobre los archivos y se puede
utilizar para comprobar si el archivo especificado ya existe
o no ha sido creado. Al constructor de esta clase se le
puede pasar como parámetro la ruta o nombre del archivo
File donde se quiere guardar la información.

File archivo = new File(getRutaArchivo());

Se utiliza para especificar el fichero en el que se quiere

FileWriter escribir, es decir permite que se escriba información en el
archivo.

También tiene la función de permitir escribir en el archivo

pero lo hace de una forma más eficiente, permitiendo
escribir grandes cantidades de información y minimizando
el número de operaciones de escritura que se realizan. El
BufferedWriter buffer necesita saber cuál es el fichero, este se
proporciona dese la clase FileWriter.

BufferedWriter escribir = new BufferedWriter(new FileWriter(archivo, true));

Para poder leer la información de un archivo desde una aplicación en Java y

visualizar su información, se deben utilizar las siguientes clases:

Nombre de la Clase Descripción

FileReader Permite leer la información de un archivo especificado, los
métodos de esta clase permiten leer caracteres a bajo
nivel, esta clase usualmente está contenida por objetos de
alto nivel de la clase BufferedReader.

FileReader f = new FileReader(rutaArchivo);

BufferedReader Permite leer las cadenas de texto almacenadas en el

archivo. Puede leer grandes cantidades de información de
un archivo y mantenerlas en el buffer, reduciendo el
número de veces que se tiene que acceder directamente
al archivo.
BufferedReader leer = new BufferedReader(f);
 CURSO PROGRAMACIÓN II
UNIVERSIDAD DE CÓRDOBA
IV SEMESTRE

 Ejercicio Propuesto:

En el siguiente ejemplo se capturaran datos de tipo cadena correspondientes a los

nombres de personas que se quieren guardar en el archivo. Se creara físicamente
en el disco duro un fichero plano que guardara los nombres que se vayan
agregando al archivo. Igualmente se implementara un método que permite abrir el
archivo y leer línea a línea la información registrada. Finamente se implementan
métodos para determinar cuántos nombres hay guardados en el archivo y se
visualiza información del archivo utilizando los métodos de la clase File.

Implementación de la clase LeerEscribirArchivo:

En el fichero LeerEscribirArchivo.java se declara la clase LeerEscribirArchivo,

que tendrá como atributo el nombre que tendrá el archivo y los métodos que
permiten leer y escribir.

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class LeerEscribirArchivo {
private String rutaArchivo; //Atributo para asignar el nombre del archivo.
File archivo;
public void LeerEscribirArchivo(){ //Método constructor de la clase.
rutaArchivo = "";
}
public void setRutaArchivo(String nom){ //Método modificador para asignar el nombre del archivo
rutaArchivo = nom;
}
public String getRutaArchivo(){ //Método para obtener el nombre del archivo.
return rutaArchivo;
}

//Método para guardar los datos de tipo cadena pasados como parámetro en el archivo.
public void guardarArchivo(String dato) throws IOException{
//Se crea un objeto de la clase File llamado archivo y se pasa como parámetro al constructor de la
//clase File el nombre o ruta del archivo.
archivo = new File(getRutaArchivo());
BufferedWriter escribir; //Se declara un objeto de la clase BufferedWriter llamado escribir.
if(archivo.exists()) { //Si el archivo existe, se agrega el dato después de la última línea.
//Se crea el objeto de la clase BufferedWriter y se pasa a su constructor el objeto de la clase File.
escribir = new BufferedWriter(new FileWriter(archivo, true));
escribir.write(dato); //Se escribe el dato pasado como parámetro con el método write.
escribir.newLine(); //Para asignar una nueva línea en el archivo.
} else { //Si el archivo no existe, se crea y se le asigna el primer dato en el archivo.
escribir = new BufferedWriter(new FileWriter(archivo));
escribir.write(dato);
escribir.newLine();
 CURSO PROGRAMACIÓN II
UNIVERSIDAD DE CÓRDOBA
IV SEMESTRE

}
escribir.close();
}

//Implementación del método que permite abrir el archivo para leer línea a línea los datos.
public String leerArchivo(String rutaArchivo) throws FileNotFoundException, IOException {
String linea; //variable para asignar cada línea del archivo.
String verDatosArchivo=""; //Variable par air almacenado toda la información del archive.
//Se crea un objeto de la clase FileReader para pasarlo como parámetro al constructor del objeto
//que se crea de la clase BufferedReader (leer).
FileReader fichero = new FileReader(rutaArchivo);
BufferedReader leer = new BufferedReader(fichero);
//Mientras que se pueda leer la línea, se va almacenado la información leída en cada línea, en la
//variable verDatosArchivo para posteriormente mostrarlos.
while((linea = leer.readLine())!= null) {
verDatosArchivo = verDatosArchivo+String.valueOf(linea+"\n");
}
leer.close();
return verDatosArchivo;
}
//Método para contabilizar el número de líneas almacenadas en el archivo.
public int cantidadLineasArchivo() throws FileNotFoundException, IOException{
int numeroLineas = 0;
String linea;
FileReader fichero = new FileReader(getRutaArchivo());
BufferedReader leer = new BufferedReader(fichero);
while((linea = leer.readLine())!= null) {
numeroLineas++;
}
leer.close();
return numeroLineas;
}
}

Implementación de la clase Main:

En el fichero Main.java se declaran los métodos que permiten capturar la

información para almacenarla en el archivo y visualizar el contenido del archivo.

import java.io.File;
import java.io.IOException;
import javax.swing.JOptionPane;
public class Main {
//Método para visualizar el menú de opciones del programa.
public static int menu(){
int opcion = 0;
do{
opcion = Integer.parseInt(JOptionPane.showInputDialog("=== IMPLEMENTACIÓN DE
ARCHIVOS - OPCIÓN DEL MENÚ ===\n\n"
+"1. Guardar Nombres en el Archivo \n"+"2. Listar los Nombres del Archivo \n"+"3. Cantidad
de Nombres Guardados\n"+
 CURSO PROGRAMACIÓN II
UNIVERSIDAD DE CÓRDOBA
IV SEMESTRE

"4. Informacion General del Archivo \n"+"5. Salir"+"\n \n Seleccione una opcion del 1 al
5"));
}while(opcion <= 0 || opcion > 5);
return opcion;
}

//Método que permite obtener información del archivo, creando un objeto de la clase File (inf) y
//utilizando sus métodos, como son getAbsolutePath() para ave la ruta absoluta del archivo y
//length() para conocer su tamaño.
public static void informeArchivo(LeerEscribirArchivo arch){
File inf = new File(arch.getRutaArchivo());
JOptionPane.showMessageDialog(null,"====== INFORMACÓN DEL ARCHIVO
======"+"\n"+"\n Ubicación: "+
inf.getAbsolutePath()+"\n Tamaño: "+ inf.length());
}
public static void main(String[] args) throws IOException {
int opcion;
LeerEscribirArchivo arch = new LeerEscribirArchivo();
arch.setRutaArchivo("D:\\personas.txt");
do{
opcion = menu();
switch(opcion) {
case 1:
String dato = JOptionPane.showInputDialog(null, "Digite el NOMBRE: ");
arch.guardarArchivo(dato);
break;
case 2:
JOptionPane.showMessageDialog(null,"====== NOMBRES DEL ARCHIVO
======"+"\n"+
arch.leerArchivo(arch.getRutaArchivo())+"\n");
break;
case 3:
JOptionPane.showMessageDialog(null,"====== NOMBRES DEL ARCHIVO
======"+"\n"+"\n"+"Se han registrado: "+
arch.cantidadLineasArchivo()+" Nombres \n\n");
break;
case 4:
informeArchivo(arch);
break;
case 5:
break;
}
}while(opcion != 5);
}
}