Tutorial de Java: Archivos.
Tutorial de Java: Archivos.
Un archivo puede definirse como una secuencia de elementos del mismo tipo, que residen generalmente en memoria auxiliar. Los archivos son utilizados cuando el volumen de datos a procesar es grande y no cabe en la memoria central del computador. Adicional a la memoria principal, los archivos pueden ser almacenados en dispositivos de memoria auxiliar como discos, disquetes, cintas, cartuchos zip, cd, pen drive o memory flash, entre otros.
- Características básicas de los Archivos:
- i. Los archivos son utilizados cuando se desea que los datos puedan recuperarse aún después de haber apagado la máquina y también cuando se manejan grandes volúmenes de información.
- ii. Residen en memoria auxiliar, la cual generalmente, es más económica, grande, pero lenta que la memoria principal del computador.
iii. Los elementos que almacena un archivo pueden ser elementales (texto, números) o estructurados (arreglos, registros). Para propósitos del curso, sólo se puede leer un archivo elemento por elemento.
- iv. La cantidad de componentes que constituyen el archivo, es en teoría, ilimitada (no se conoce a priori). Si tiene cero elementos se dice que es un archivo vací
- v. Cuando la estructura de un archivo no parece contener elementos de un solo tipo, si decimos que todos los elementos del archivo es un gran registro, no rompe la definición anterior (es un caso particular de un archivo con un solo elemento de tipo registro).
- vi. Los archivos más comunes son los archivos secuencial Los elementos de un archivo secuencial están dispuestos uno tras otro, y para acceder un elemento en particular, hay que pasar por todos los anteriores. Por esos se les llama de acceso secuencial, a diferencia de los arreglos que son de acceso aleatorio. Sin embargo, los elementos del archivo también puedes ser extraídos de manera directa, pero este objetivo escapa del alcance del curso.
- b. Declaración de Archivos: Consiste en indicar el nombre de la variable que será utilizada en el algoritmo para hacer Referencia al archiv
- i. Declaración por Variable: se declara la variable tipo archivo como si se tratara de una variable de tipo de dato simpl
- ii. Declaración por Tipo: al igual que los arreglos y los registros, se
antecede la palabra reservada Tipo a la declaración y luego se declaran las variables del tipo.
- Operaciones básicas en Archivos Secuenciales: Estas operaciones se consideran operaciones primitivas y reservadas del pseudo-código. Entre las operaciones básicas en archivos secuenciales tenemos las siguientes:
- i. Abrir el Archivo: Ubica y prepara el archivo para poder trabajar
con él.
donde:
Acción AbrirArchivo (Ref Archivo A; String
<ruta_del_archivo>, <Argumentos>)
- <ruta_del_archivo> indica la ruta en memoria o al menos el nombre del archivo con el cual se va a trabajar, por ejemplo, C/Mis documentos/datosprueba.txt o DatosParticipantes.doc.
- <Argumentos> es uno o más de las siguientes palabras reservadas:
o Escritura: indica que el archivo se abre de solo escritura.
o Lectura: indica que el archivo de abre de solo lectura.
o Añadir: indica que el archivo se abre de escritura pero todo lo que se escriba se añade al final del archivo.
o Texto: indica que el archivo a abrir es un archivo de texto.
o Binario: indica que el archivo a abrir es un archivo binario
(un archivo diferente a un archivo de texto).
Los argumentos pueden ser combinados con el operador lógico
- y. Por ejemplo: AbrirArchivo(A, “prueba.txt”, Lectura y Texto).
En el parámetro argumentos, normalmente se indica como mínimo, uno de los tipos de archivo (lectura, escritura, añadir) y uno de los tipos de datos para sus elementos (texto, binario). Los argumentos también son llamados flags.
Comentario: El archivo se abre una sola vez en el algoritmo, al principio del mismo y debe ser cerrado al finalizar el mismo.
- ii. Cerrar el archivo: Cuando se desea dejar de trabajar con un archivo, debe cerrarse para que esté disponible para otras aplicacion Sólo los archivos que están abiertos pueden cerrarse. Si un archivo no se cierra se puede perder información en el mismo.
Acción CerrarArchivo(Ref Archivo A)
iii. Fin de archivo (FDA, EOF): indica si no hay más elementos para leer en el archivo. Sólo se usa para archivos de lectura. Retorna verdadero si se alcanzó el fin del archivo y falso en caso contrario.
Función FDA(Ref Archivo A) : lógico
- iv. Leer del archivo: Lee un element Aunque una lectura no modifica el archivo físicamente en disco, la variable Archivo si es modificada (por ejemplo, cambia la posición actual del cursor del archivo), por lo tanto debe pasarse por Referencia.
Acción LeerArchivo(Ref Archivo A, Ref <elemento_tipo> x)
- v. Escribir en el archivo: escribe un elemento en el archiv
Acción EscribirArchivo(Ref Archivo A, <elemento_tipo> x)
- d. Recorrido secuencial para tratar un archivo: Supongamos que utilizamos dos archivos de texto: A es de lectura y será el archivo a recorrer a través de operaciones de lectura, B es de escritura y se utilizará para mostrar los resultado
La idea fundamental es recorrer el archivo de entrada o lectura una sola vez a través del uso de una estructura de iteración que finalice cuando la operación FDA retorne verdadero. Los ciclos Mientras o Repetir son los más adecuadas para este recorrido, el Para no resulta tan conveniente, a menos que conozcamos cuantos registros tiene el archivo o el problema este limitado a leer una cantidad determinada de ellos. El archivo de salida, si se pide que se genere, se creará en el ciclo de recorrido ya que la idea es realizar la lectura del archivo origen y la creación del archivo resultado al mismo tiempo, es decir, en un solo ciclo.
La acción de impresión del archivo de salida requiere que el archivo abierto como escritura sea cerrado y reabierto como de lectura, de manera que sea recorrido y en cada paso se escriba el contenido de cada uno de sus registros.
A continuación se suministrará un esquema para este recorrido, que si bien no es 100% general o no es aplicable para todos los problemas de recorrido de archivos, puede servir como base para la resolución de los ejercicios clásicos donde se usa un archivo de entrada, se genera un archivo de salida y se realizan cálculos adicionales. En el ejemplo se contarán la cantidad de caracteres existentes en el archivo de entrada.
Una de tantas maneras de implementar archivos en java es la siguiente: Creación de un archivo:
File archivo = new File («C:\\archivo.txt»); Leer un de un archivo:
class LeeFichero {
public static void main(String [] arg) { File archivo = null;
FileReader fr = null; BufferedReader br = null;
try {
// Apertura del fichero y creacion de BufferedReader para poder
// hacer una lectura comoda (disponer del metodo readLine()).
archivo = new File («C:\\archivo.txt»);
fr = new FileReader (archivo);
br = new BufferedReader(fr);
// Lectura del fichero String linea; while((linea=br.readLine())!=null)
System.out.println(linea);
}
catch(Exception e){
e.printStackTrace();
}finally{
// En el finally cerramos el fichero, para asegurarnos
// que se cierra tanto si todo va bien como si salta
// una excepcion. try{
if( null != fr ){
fr.close();
}
}catch (Exception e2){
e2.printStackTrace();
}
}
}
}
Escribir en un archivo:
public class EscribeFichero
{
public static void main(String[] args)
{
FileWriter fichero = null; PrintWriter pw = null;
try
{
fichero = new FileWriter(«c:/prueba.txt»);
pw = new PrintWriter(fichero);
for (int i = 0; i < 10; i++)
pw.println(«Linea » + i);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
// Nuevamente aprovechamos el finally para
// asegurarnos que se cierra el fichero. if (null != fichero)
fichero.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
}
}
Si usamos sólo FileImputStream, FileOuoutStream, FileReader o FileWriter, cada vez que hagamos una lectura o escritura, se hará físicamente en el disco duro. Si escribimos o leemos pocos caracteres cada vez, el proceso se hace costoso y lento, con muchos accesos a disco duro.
Los BufferedReader, BufferedInputStream, BufferedWriter y Buffered OutputStream añaden un buffer intermedio. Cuando leamos o escribamos, esta clase controlará los accesos a disco:
- Si vamos escribiendo, se guardará los datos hasta que tenga bastantes datos como para hacer la escritura eficiente.
- Si queremos leer, la clase leerá muchos datos de golpe, aunque sólo nos dé los que hayamos pedido. En las siguientes lecturas nos dará lo que tiene almacenado, hasta que necesite leer otra vez.
Esta forma de trabajar hace los accesos a disco más eficientes y el programa correrá más rápido. La diferencia se notará más cuanto mayor sea el fichero que queremos leer o escribir.
Si quieres seguir aprendiendo con nosotros, puedes ingresar a nuestros
