ARCHIVOS

DESARROLLO

CONCEPTO DE ARCHIVOS:

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 (Pastrana, 2005). 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).

VENTAJAS DE UTILIZAR 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.

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 (SekthDroid, 2013). 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;
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 donde se quiere guardar
File la información.

File archivo = new File(getRutaArchivo());

Se utiliza para especificar el fichero en el que se quiere escribir,

FileWriter 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
BufferedWriter operaciones de escritura que se realizan. El 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

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
FileReader clase BufferedReader.

FileReader f = new FileReader(rutaArchivo);

Permite leer las cadenas de texto almacenadas en el archivo.

Puede leer grandes cantidades de información de un archivo y
BufferedReader mantenerlas en el buffer, reduciendo el número de veces que se
tiene que acceder directamente al archivo.
BufferedReader leer = new BufferedReader(f);
EJERCICIO PROPUESTO USANDO ARCHIVOS EN JAVA:

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.

 Diseño de clases UML de la solución

 Implementación de la clase DeclararPila en el fichero LeerEscribirArchivo.java

En el fichero LeerEscribirArchivo.java se declara la clase LeerEscribirArchivo, que tendrá los

métodos que permiten realizar las operaciones de escribir y leer información en el archivo; además,
se cuentan el número de líneas que tiene el archivo. La clase tiene como atributo el nombre que
tendrá el archivo.

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.
//Si se quiere añadir al final de un fichero ya existente, simplemente se poner true
//como segundo parámetro del constructor de FileWriter.
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();
}
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

En el fichero Main.java se declara la clase Main, que tendrá el método que permite visualizar
información del archivo utilizando los métodos de la clase File. El menú de opciones para realizar
las operaciones de leer y escribir datos en el 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"+
"4. Informacion General del Archivo \n"+"5. Salir"+"\n \n Seleccione una opción 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);
}
}

EJERCICIOS/ACTIVIDADES

 Estudiar el comportamiento de la clase StringTokenizer para poder leer los datos almacenados en
una línea del archivo y dividirlos, utilizando algún carácter que actué como separador o delimitador
de toda la cadena de caracteres. Suponiendo que se tiene un archivo plano que tiene almacenada la
información correspondiente a la identificación, nombre y edad de una persona; separados por el
delimitador tabulado (\t).

Implementar en Java la clase y los métodos que permitan almacenar información de las personas
en el archivo y leer la información del para visualizarla.

 Se quiere almacenar en un fichero plano la información de los niños matriculados en un jardín

infantil que maneja los grados de Prejardín y Jardín, tener en cuenta que la edad de los niños que
ingresan a estos cursos debe estar entre los 4 y 7 años. Entre los datos básicos que se quieren
registrar de cada niño se encuentran: La identificación, nombre completo y sexo.

Además de permitir guardar la información de los estudiantes en el archivo, la directora del jardín
infantil necesita que la aplicación le permita consultar la información de sus estudiantes y realice
las siguientes operaciones sobre los datos.

o Buscar en el archivo la información de un niño, utilizando como dato de búsqueda la

identificación. Esto teniendo en cuenta que al ingresar la información de cada niño la
identificación no se repite.

o Borrar el contenido de un registro específico del archivo, utilizando otro archivo temporal
o auxiliar.
 Se requiere generar un informe detallado que muestre la siguiente información:

o Cuantos estudiantes en total hay matriculados por cada grado (Jardín y Prejardín),
determinando por separado el número de niñas y niños por grado.

o Un listado general con los nombres de todos los niños matriculados en Prejardín.

o Un listado general con los nombres de todos los niños matriculados en Jardín.

o Promedio de edad de los niños y niñas de todo el jardín infantil (ambos promedios por
separado).

BIBLIOGRAFÍA

Pastrana Brincones, José. (2005). Práctica 13: Ficheros en C++. Laboratorio de Programación 1ºA
E.T.S.I. Informática Gestión. Disponible en: https://es.scribd.com/document/42047356/ficherosc

SekthDroid. (2013). Navegación de Archivos y I/O en Java. Disponible en:

https://sekthdroid.wordpress.com/tag/java-bufferedwriter/