Introducción a los Threads en JAVASin categoría 

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.

  1. Características básicas de los Archivos:

 

  1. 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.
  2. 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.

  1. 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í
  2. 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).
  3. 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.

 

 

  1. b. Declaración de Archivos: Consiste en indicar el nombre de la variable que será utilizada en el algoritmo para hacer Referencia al archiv

 

  1. i. Declaración por  Variable:  se  declara  la  variable  tipo  archivo como si se tratara de una variable de tipo de dato simpl
  2. 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.

 

 

  1. 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:
  2. 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

 

  1. 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.

 

 

  1. 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

 

 

 

  1. 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)

 

 

 

  1. v. Escribir en el archivo: escribe un elemento en el archiv

 

 

 

Acción EscribirArchivo(Ref Archivo A, <elemento_tipo> x)

 

 

 

  1. 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

Cursos y Diplomados de Tecnología Web visita www.uneweb.edu.ve  para más información

Related posts