Archivos secuenciales dentro de los lenguajes de programacin.

Gabriel Michel Carrillo

10231485 Instituto Tecnologico Superior de Lerdo 17/02/2012 1121

Contenido
LENGUAJE DE PROGRAMACIN ..................................................................................................3 LENGUAJES DE PROGRAMACIN IMPERATIVOS Y FUNCIONALES ........................................... 4 Interpretacin y compilacin ......................................................................................................... 4 CONCEPTOS Y DEFINICIONES ......................................................................................................7 FICHERO ....................................................................................................................................7 ESTRUCTURA DE REGISTROS ...................................................................................................7 DEFINICIONES : ........................................................................... Error! Marcador no definido. CLASIFICACIN DE REGISTROS ..................................................................................................10 REGISTROS DE LONGITUD FIJA : ................................................................................................10 OPERACIONES CON REGISTROS ................................................................................................12 FORMA LGICA : .....................................................................................................................12 PSEUDOCDIGO : ....................................................................................................................... 13 FICHEROS SECUENCIALES : .................................................................................................... 13 Actualizacin interactiva : .....................................................................................................21 Archivos secuenciales ...................................................................................................................25 Consulta o recorrido secuencial ................................................................................................25 C# ............................................................................................................................................... 26 Manejo de Archivos en C# ....................................................................................................... 26 Using System.IO ....................................................................................................................... 27 Escritura con StreamWriter ..................................................................................................... 29 Ejemplos de Manejo de Archivos en C# ....................................................................................30 Ejemplo de Ejecucin:........................................................................................................... 35 PHP ..............................................................................................................................................39 Java ............................................................................................................................................. 42 [cdigo] Crear un archivo secuencial en Java .............................................................. 42 El resultado ................................................................................................................... 42 El cdigo ........................................................................................................................43 Delphi XE2 ................................................................................................................................... 54

LENGUAJE DE PROGRAMACIN
Un lenguaje de programacin" es un lenguaje diseado para describir el conjunto de acciones consecutivas que un equipo debe ejecutar. Por lo tanto, un lenguaje de programacin es un modo prctico para que los seres humanos puedan dar instrucciones a un equipo. Por otro lado, el trmino "lenguaje natural" define un medio de comunicacin compartido por un grupo de personas (por ejemplo: ingls o francs). Los lenguajes que los equipos usan para comunicarse entre ellos no tienen nada que ver con los lenguajes de programacin; se los conoce como protocolos de comunicacin. Se trata de dos conceptos totalmente diferentes. Un lenguaje de programacin es muy estricto: A CADA instruccin le corresponde UNA accin de procesador. El lenguaje utilizado por el procesador se denomina lenguaje mquina. Se trata de datos tal como llegan al procesador, que consisten en una serie de 0 y 1 ( datos binarios). El lenguaje mquina, por lo tanto, no es comprensible para los seres humanos, razn por la cual se han desarrollado lenguajes intermediarios comprensibles para el hombre. El cdigo escrito en este tipo de lenguaje se transforma en cdigo mquina para que el procesador pueda procesarlo. El ensamblador fue el primer lenguaje de programacin utilizado. Es muy similar al lenguaje mquina, pero los desarrolladores pueden comprenderlo. No obstante, este lenguaje se parece tanto al lenguaje mquina que depende estrictamente del tipo de procesador utilizado (cada tipo de procesador puede tener su propio lenguaje mquina). As, un programa desarrollado para un equipo no puede ser portado a otro tipo de equipo. El trmino "portabilidad" describe la capacidad de usar un programa de software en diferentes tipos de equipos. Para poder utilizar un programa de software escrito en un cdigo ensamblador en otro tipo de equipo, a veces ser necesario volver a escribir todo el programa! Por lo tanto, un lenguaje de programacin tiene varias ventajas:

es mucho ms fcil de comprender que un lenguaje mquina: permite mayor portabilidad, es decir que puede adaptarse fcilmente para ejecutarse en diferentes tipos de equipos.

LENGUAJES DE FUNCIONALES

PROGRAMACIN

IMPERATIVOS

Los lenguajes de programacin generalmente se dividen en dos grupos principales en base al procesamiento de sus comandos: lenguajes imperativos; lenguajes funcionales.

Lenguaje de programacin imperativo Un lenguaje imperativo programa mediante una serie de comandos, agrupados en bloques y compuestos de rdenes condicionales que permiten al programa retornar a un bloque de comandos si se cumple la condicin. Estos fueron los primeros lenguajes de programacin en uso y an hoy muchos lenguajes modernos usan este principio. No obstante, los lenguajes imperativos estructurados carecen de flexibilidad debido a la secuencialidad de las instrucciones. Lenguaje de programacin funcional Un lenguaje de programacin funcional(a menudo llamado lenguaje procedimental) es un lenguaje que crea programas mediante funciones, devuelve un nuevo estado de resultado y recibe como entrada el resultado de otras funciones. Cuando una funcin se invoca a s misma, hablamos de recursividad.

Interpretacin y compilacin
Los lenguajes de programacin pueden, en lneas generales, dividirse en dos categoras: lenguajes interpretados lenguajes compilados Lenguaje interpretado Un lenguaje de programacin es, por definicin, diferente al lenguaje mquina. Por lo tanto, debe traducirse para que el procesador pueda comprenderlo. Un programa escrito en un lenguaje interpretado requiere de un programa auxiliar (el intrprete), que traduce los comandos de los programas segn sea necesario. Lenguaje compilado Un programa escrito en un lenguaje "compilado" se traduce a travs de un programa anexo llamado compilador que, a su vez, crea un nuevo archivo

independiente que no necesita ningn otro programa para ejecutarse a s mismo. Este archivo se llama ejecutable. Un programa escrito en un lenguaje compilado posee la ventaja de no necesitar un programa anexo para ser ejecutado una vez que ha sido compilado. Adems, como slo es necesaria una traduccin, la ejecucin se vuelve ms rpida. Sin embargo, no es tan flexible como un programa escrito en lenguaje interpretado, ya que cada modificacin del archivo fuente (el archivo comprensible para los seres humanos: el archivo a compilar) requiere de la compilacin del programa para aplicar los cambios. Por otra parte, un programa compilado tiene la ventaja de garantizar la seguridad del cdigo fuente. En efecto, el lenguaje interpretado, al ser directamente un lenguaje legible, hace que cualquier persona pueda conocer los secretos de fabricacin de un programa y, de ese modo, copiar su cdigo o incluso modificarlo. Por lo tanto, existe el riesgo de que los derechos de autor no sean respetados. Por otro lado, ciertas aplicaciones aseguradas necesitan confidencialidad de cdigo para evitar las copias ilegales (transacciones bancarias, pagos en lnea, comunicaciones seguras...). Lenguajes intermediarios Algunos lenguajes pertenecen a ambas categoras (LISP, Java, Python...) dado que el programa escrito en estos lenguajes puede, en ciertos casos, sufrir una fase de compilacin intermediaria, en un archivo escrito en un lenguaje ininteligible (por lo tanto diferente al archivo fuente) y no ejecutable (requerira un intrprete). Los applets Java, pequeos programas que a menudo se cargan en pginas web, son archivos compilados que slo pueden ejecutarse dentro de un navegador web (son archivos con la extensin .class). Ejemplos de lenguajes ampliamente usados A continuacin, encontrar una breve lista de los lenguajes de programacin actuales: Lenguaje ADA BASIC C C++ Cobol Fortran Principal rea de aplicacin Tiempo real Programacin para fines educativos Programacin de sistema Compilado/interpretado Lenguaje compilado Lenguaje interpretado Lenguaje compilado

Programacin de sistema orientado a Lenguaje compilado objeto Administracin Clculo Lenguaje compilado Lenguaje compilado

Java MATLAB Clculos matemticos LISP Pascal PHP

Programacin orientada a Internet Clculos matemticos Clculos matemticos Inteligencia artificial Educacin Desarrollo de sitios web dinmicos

Lenguaje intermediario Lenguaje interpretado Lenguaje interpretado Lenguaje intermediario Lenguaje compilado Lenguaje interpretado Lenguaje interpretado Lenguaje interpretado

Inteligencia artificial Inteligencia artificial Perl Procesamiento de cadenas de caracteres

CONCEPTOS Y DEFINICIONES
FICHERO
Un fichero es un conjunto de datos estructurados que pueden estar almacenados en un soporte de datos de forma que puedan ser tratados o utilizados de forma individual o global. Cada fichero se tiene que identificar con un nombre. Los elementos que forman un fichero se llaman registros y dichos registros se definen como la unidad mnima de informacin completa de un fichero.

ESTRUCTURA DE REGISTROS
Existen dos tipos de registros: Registro lgico: Son estructuras de datos homogneas que hacen referencia a una misma entidad o cosa. Esta estructura est dividida a su vez en unos elementos ms pequeos a los cuales denominaremos Campos, estos podrn ser del mismo o diferente tipo. Podramos considerar al registro como una unidad de tratamiento incluida dentro de un fichero. Registro fsico: Un registro fsico al que podemos llamar tambin bloque, es la cantidad de informacin que el sistema operativo puede transferir como unidad al realizar una operacin de entrada y salida entre la memoria principal del ordenador y los perifricos o dispositivos de almacenamiento. El tamao de un bloque o registro fsico depender o variar en funcin de las caractersticas del ordenador.

DEFINICIONES:
Campo: Llamaremos campo a cada uno de los elementos que constituyen un registro lgico, considerndolo como una unidad de tratamiento independiente dentro del mismo registro. Cada campo se caracteriza y se diferencia de los dems dentro de un registro por: El tipo de dato que tiene asociado (numrico, alfanumrico, lgico, de tipo fecha, de campo memo,... etc.). El identificador o nombre a travs del cual podemos referenciarle y acceder a su contenido (nombre, apellidos, direccin, fecha de nacimiento,... etc.).

El tamao del dato (20 bytes, 45 bytes,... etc.). Subcampo: Los campos de un registro, con frecuencia, se pueden subdividir en unidades de tratamiento con las mismas caractersticas que un campo. De esta forma podemos establecer cierta jerarqua entre los datos almacenados dentro de un fichero y ms concretamente dentro de cada registro. Esta jerarqua deber tenerse en cuenta a la hora de tratar o procesar la informacin que tenemos almacenada. Dentro de un Subcampo puede haber ms subcampos. Campo clave: Para poder diferenciar a un registro de otro dentro de un fichero, se tiene que recurrir a una informacin que sea nica. Esta informacin slo nos la puede ofrecer el campo clave. Este campo solo se puede crear con independencia del resto de la informacin (campos) del registro o por defecto se puede utilizar un campo de los ya existentes y disponibles en la estructura de dicho registro. El objetivo es poder realizar a travs de l operaciones de bsqueda y clasificacin. La definicin de un campo clave en un fichero no es obligatoria, es decir, se puede carecer de ella o puede estar formada por varias definiciones de campos claves, en cuyo caso se establecern diferentes categoras entre ellas, dando lugar a lo que denominaremos como clave principal y claves secundarias. Bloqueo de registro o registro bloqueado: Un registro puede constar de un nmero variable de registros lgicos, por tanto, suponiendo que utilizramos como soporte de almacenamiento el disco, podramos transferir varios registros lgicos de la memoria al disco y del disco a la memoria en una sola operacin de entrada y salida. Este fenmeno recibe el nombre de bloqueo y el registro fsico as formado se llama bloque. Registro expandido: Es justamente el concepto contrario del registro bloqueado, cuando el registro lgico ocupa varios bloques se le da la denominacin de registro expandido. Factor de bloqueo: Con factor de bloqueo hacemos alusin al conjunto o nmero de registros lgicos que pueden entrar o estar contenidos en un bloque o registro fsico. Ejemplo: 210 97 Tamao del registro lgico.

16 2 Factor de bloqueo. Resto: N de bytes que sobran. Tamao del registro fsico. REGISTRO LGICO NOMBRE APELLIDOS DIRECCIN EDAD Tamao: 97 bytes REGISTR FSICO O BLOQUE DE 210 Bytes REGISTRO LGICO 1 REGISTRO LGICO 2? Factor de bloqueo=2 Espacio sobrante=16 bytes Estructura de registros : FICHERO 1 2 3 4 5 6 7 8 9 10 11 12 REGISTRO 7 COD_ALUMNO NOMBRE APELLIDOS FECHA_NAC CAMPO FECHA_NAC DIA MES AO SUBCAMPO DIA

CLASIFICACIN DE REGISTROS
Ejemplo : Tamao : Registro 30 Campo 1 8 Se definen al principio del programa Campo 2 12 Campo 3 10 Con igual nmero de campos pero distinta longitud, cambia la longitud. Tenemos que expresar la longitud de cada campo .
Poniendo al principio del registro el tamao de los tres campos, ser ms rpido que el anterior porque mira los tres campos de una sola vez. Cuando se tiene un nmero de campos igual en ambos registros, pero estos son de distinta longitud de campo en los mismos o diferentes registros.

REGISTROS DE LONGITUD FIJA :

Ejemplos : Mismo nmero de campos por registro e igual longitud de los campos en los mismos y distintos registros. Registro 1 A B C D E F G H I J K L M Registro 2 A B C D E F G H I J K L M Igual nmero de campos por registro, y distinta longitud de cada campo del mismo registro e idntica longitud del mismo campo en distintos registros. Registro 1 A B C D E F G Registro 2 A B C D E F G Igual nmero de campos por registro, y distinta longitud de campos en los mismos y diferentes registros. Registr 1 A B C D .................................. N

Registro 2 A B C D ........................ N Registro 3 A B C D .................................. N

OPERACIONES CON REGISTROS

FORMA LGICA :
Las dos operaciones esenciales que se pueden realizar con los registros son las siguientes : LECTURA : Esta operacin implica el movimiento de informacin que va desde el fichero a la Memoria Central del ordenador. Esta informacin est contenida en un registro. Para guardar la informacin del registro en la memoria central habr que asignar unas variables. En la operacin de lectura los nombres de las variables que estn encargadas de almacenar los datos del registro ledo se habrn asignado a los campos del mismo. Los datos no desaparecen de la memoria auxiliar, sino que se copian en las variables antes mencionadas. En este momento ya podemos proceder a su uso para lo que queramos. Si realizamos una nueva lectura, los datos del nuevo registro ocuparn el lugar del anterior sustituyndolos. Solo podemos disponer de un registro en cada instante del proceso. Cuando el fichero se acaba, el sistema detecta que lo que ha ledo no es un registro, a esto se le llama marca de fin de fichero. Un fichero de entrada es aquel que se utiliza para hacer operaciones de lectura, el flujo de informacin va desde el fichero a la memoria central. ESCRITURA O GRABACIN : Esta opcin implica movimiento de informacin desde la memoria central hacia el fichero en cuestin. La informacin comprende al de las variables cuyos nombres coincidan con los campos definidos para un fichero El fichero de salida es aquel que recibe la informacin de la memoria central y la escribe es sus registros. Utilizando la lectura y escritura de registros podemos realizar una serie de operaciones, que son las siguientes:

Altas : Consiste en la adicin o insercin de uno o ms registros en el fichero. Esta operacin slo ser posible si el fichero ya existe. Bajas : Consiste en eliminar uno o varios registros del fichero. Esta operacin requiere un primer proceso de lectura para la localizacin del registro que se pretende borrar. Modificaciones : Consiste en realizar un cambio total o parcial de uno o varios campos de los registros de un fichero. Esta operacin requiere un primer proceso de lectura para la localizacin del registro que se desea modificar y un segundo proceso de escritura para la actualizacin de todo o parte del registro. Consultas : Esta operacin nos permite acceder a uno o varios registros con la intencin de visualizar el contenido total o parcial de sus campos en pantalla o impresora en forma de listados ordenados siguiendo ciertos criterios de clasificacin establecidos por el usuario.

PSEUDOCDIGO :
FICHEROS SECUENCIALES :
Consultas : Se supone : Un fichero lgico llamado Fich. Un registro llamado R_Fich. La condicin establecida campo_n = valor introducido por teclado. El fichero Fich est asignado a un fichero fsico y abierto para lectura. a) Consulta en un fichero secuencial desordenado : Bsqueda de un registro :

INICIO Abrir Fich de lectura Leer valor sw=0 Mientras no FF (Fich) y sw=0 hacer leer R_Fich de Fich Si campo_n = valor entonces sw=1 Finsi Finmientras Si sw=1 entonces escribir R_Fich sino escribir No encontrado Finsi Cerrar Fich Fin b) Consulta en un fichero secuencial ordenado : Bsqueda de un registro : INICIO Abrir Fich de lectura Leer valor sw = 0

Mientras no FF (Fich) hacer Leer R_Fich de Fich Si campo_n >= valor sw = 1 Finsi Finmientras Si sw = 1 y campo_n = valor entonces Escribir R_Fich Sino Escribir No encontrado Finsi Cerrar Fich Fin Bsqueda de todos los registros : INICIO Abrir Fich de lectura Leer valor sw = 0 Encontrado = F Mientras no FF (Fich) y sw = 0 hacer Leer R_Fich de Fich Si campo_n > valor entonces sw = 1

Sino Si campo_n = valor entonces Escribir R _Fich Escribir Encontrado = V Finsi Finsi Finmientras Si Encontrado = F Escribir No encontrado Finsi Cerrar Fich Fin Actualizacin por lotes : Se actualiza un fichero origen ordenado por un campo clave con un lote de transacciones contenidas en un fichero de movimientos con la misma ordenacin que el fichero origen, adems contiene un campo que indica el tipo de movimientos ( alta, baja, o modificacin ). Esto implica que la informacin que no sea baja o errnea pasa al fichero destino con los registros ordenados y actualizados. Los errores producidos en la actualizacin pueden ser enviados a una impresora o escritos en el soporte de almacenamiento para su posterior tratamiento. Para la actualizacin, se van a utilizar cuatro ficheros : Un fichero de origen ( Fich_origen ) Un fichero de movimientos ( Fich_mov ) Un fichero de destino ( Fich_destino ) Un fichero de errores ( Fich_errores ) INICIO

Variables : clave_origen clave_destino registro_origen registro_destino registro_mov registro_error resto_destino resto_mov Abrir Fich_origen de lectura Abrir Fich_mov de lectura Abrir Fich_destino de escritura Abrir Fich_errores de escritura Fin_origen = 0 Fin_mov = 0 Procedimiento Leer_origen Procedimiento Leer_mov Mientras Fin_origen = 0 y Fin_mov = 0 hacer Si clave_origen < clave_mov entonces Procedimiento Copia Procedimiento Leer_origen Sino Si clave_origen > clave_mov entonces

Procedimiento Alta Procedimiento Leer_mov Sino Procedimiento Baja_modif Procedimiento Leer_origen Procedimiento Leer_mov Finsi Finsi Finmientras Mientras Fin_origen = 0 hacer Procedimiento Copia Procedimiento Leer_origen Finmientras Mientras Fin_mov = 0 hacer Procedimiento Alta Procedimiento Leer_mov Finmientras Cerrar Fich_origen, Fich_mov, Fich_destino, Fich_error Fin Procedimiento Alta : INICIO Segn sea tipo_mov `A :

clave_destino = clave_mov resto_destino = resto_mov Escribir registro_destino en Fich_destino Otros : registro_error = registro_mov Escribir registro_error en Fich_error Finsegn_sea FinSegunSea FIN Procedimiento Leer_origen : INICIO Si FF ( Fich_origen ) entonces Fin_origen = 0 Sino Leer registro_origen de Fich_origen Finsi Fin Procedimiento Leer_mov : INICIO Si FF ( Fich_mov ) entonces Fin_mov = 0 Sino Leer registro_mov de Fich_mov

Finsi Fin Procedimiento Baja_Modif : INICIO Segn_sea Tipo-mov `B : ** No se copia `M : ** Se modifican los campos deseados Escribir registro_destino en Fich_destino Otros : registro_error = registro_mov Escribir registro_error en Fich_error registro_destino = registro_orgen Escribir registro_destino en Fich_destino Finsegn_sea Finsegunsea FIN Procedimiento Copia : INICIO registro_destino = registro_origen Escribir registro_destino en Fich_destino FIN

Actualizacin interactiva :
Consiste en actualizar un fichero introduciendo datos por teclado, produciremos altas. Bajas, y modificaciones de registros. Utilizaremos un fichero temporal para organizar el fichero cuando tengamos que hacer una baja o un borrado de registro. Las altas se producen en el lugar correspondiente, tendremos que utilizar un fichero temporal para reorganizar el fichero si este est ordenado, sino las altas se realizarn aadiendo registros al fichero. Los errores se presentan en pantalla cuando se producen. Se utilizar un fichero llamado ( Fichero ) y un fichero temporal llamado ( Temp ) INICIO Variables : vclave vale_clave verif_clave clave_registro resto_registro Repetir Escribir 1. Alta 2. Baja 3. Modificacin Escribir Seleccionar operacin Leer operacin Segn_sea operacin 1 : Procedimiento Alta 2 : Procedimiento Baja 3 : Procedimiento Modificacin

Finsegn_sea Mientras operacin > 0 y operacin < 4 hacer Cerrar Fichero Fin Procedimiento Alta : INICIO Escribir Introducir clave para alta Leer vclave Vale_clave = Verif_clave ( vclave ) Cerrar Fichero Si vale_clave = V entonces Escribir Clave existente. No hay alta Sino Abrir Fichero para aadir clave_registro = vclave Leer resto_registro Escribir registro en Fichero Finsi Fin Procedimiento Baja : INICIO Escribir Introducir clave para baja Leer vclave

vale_clave = verif_clave ( vclave ) Cerrar fichero Si vale_clave = F entonces Escribir No existe clave para baja Sino Escribir registro Abrir Fichero para leer Abrir Temp para escribir Mientras no FF ( Fichero ) hacer Leer registro de Fichero Si clave_registro <> vclave entonces Escribir en Temp Finsi Finmientras Borrar_Fichero ( Fichero ) Renombrar_Fichero ( Temp, Fichero ) Finsi Fin Procedimiento Modificacin : INICIO Escribir Introducir clave para modificar registro Leer vclave vale_clave = veirf_clave ( vclave )

Si vale_clave = F entonces Escribir No existe clave para modificar sino Escribir registro ** Leer valores de campos del registro que se va a modificar. Escribir registro de Fichero Finsi Fin Procedimiento Verificar_clave ( clave) INICIO Abrir Fichero para lectura y escritura sw = 0 Mientras no FF ( Fichero ) y sw = 0 hacer Leer registro de Fichero Si clave_registro = clave sw = 1 Finsi Finmientras Si sw = 1 entonces retorno V Sino retorno F FinsiFin

Archivos secuenciales
Como su nombre lo indica, en este tipo de archivos los registros se graban en secuencia o consecutivamente y deben accesarse de ese mismo modo, es decir, conforme se van insertando nuevos registros, stos se almacenan al final del ltimo registro almacenado; por lo tanto, cuando se desea consultar un registro almacenado es necesario recorrer completamente el archivo leyendo cada registro y comparndolo con el que se busca. En este tipo de archivo se utiliza una marca invisible que el sistema operativo coloca al final de los archivos: EOF (End of File), la cual sirve para identificar dnde termina el archivo.

Consulta o recorrido secuencial

A continuacin se muestra un diagrama de flujo de una rutina de consulta de un registro en particular mediante un recorrido secuencial. En esta rutina se maneja un archivo que almacena datos de productos (PRODUCTO.SEC) segn el registro declarado en la Fig. 3 y lo recorre completamente en forma secuencial (registro por registro) hasta encontrar el producto solicitado (Fig. 7).

C#
C# (pronunciado si sharp en ingls) es un lenguaje de programacin orientado a objetos desarrollado y estandarizado por Microsoft como parte de su plataforma .NET, que despus fue aprobado como un estndar por la ECMA (ECMA-334) e ISO (ISO/IEC 23270). C# es uno de los lenguajes de programacin diseados para la infraestructura de lenguaje comn. Su sintaxis bsica deriva de C/C++ y utiliza el modelo de objetos de la plataforma .NET, similar al de Java, aunque incluye mejoras derivadas de otros lenguajes. El nombre C Sharp fue inspirado por la notacin musical, donde '#' (sostenido, en ingls sharp) indica que la nota (C es la nota do en ingls) es unsemitono ms alta, sugiriendo que C# es superior a C/C++. Adems, el signo '#' viene de cuatro '+' pegados.1 Aunque C# forma parte de la plataforma .NET, sta es una API, mientras que C# es un lenguaje de programacin independiente diseado para generar programas sobre dicha plataforma. Ya existe un compilador implementado que provee el marco Mono - DotGNU, el cual genera programas para distintas plataformas como Windows, Unix y GNU/Linux.

Manejo de Archivos en C#
La manera de almacenar y recuperar informacin que perdure en el tiempo se basa en el uso de memoria secundaria, compuesta esencialmente por discos (diskettes, discos duros, CD, DVD, etc.) y ocasionalmente cintas. En cualquiera de estos medios, la unidad de almacenamiento de informacin se denomina archivo. Streams La lectura y escritura a un archivo son hechas usando un concepto genrico llamado stream. La idea detrs del stream existe hace tiempo, cuando los datos son pensados como una transferencia de un punto a otro, es decir, como un flujo de datos. En el ambiente .NET se puede encontrar muchas clases que representan este concepto que trabaja con archivos o con datos de memoria. Un stream es como se denomina a un objeto utilizado para transferir datos. Estos datos pueden ser transferidos en dos posibles direcciones: - Si los datos son transferidos desde una fuente externa al programa, entonces se habla de leer desde el stream. - Si los datos son transferidos desde el programa a alguna fuente externa, entonces se habla de escribir al stream. Frecuentemente, la fuente externa ser un archivo, pero eso no necesariamente es el caso, por lo que el concepto es utilizado ampliamente con fuentes de informacin externas de diversos tipos. Algunas otras posibilidades fuera de los archivos incluyen:

- Leer o escribir datos a una red utilizando algn protocolo de red, donde la intencin es que estos datos sean recibidos o enviados por otro computador. - Lectura o escritura a un rea de memoria. - La Consola - La Impresora - Otros ... Algunas clases que C# provee para resolver este acceso a fuentes diversas incluyen las clases de tipo: Reader y Writer. BufferedStream Esta clase se utiliza para leer y para escribir a otro stream. El uso de streams para la lectura y escritura de archivo es directa pero lenta. Por esta razn la clase BufferedStream existe y es ms eficiente. Puede ser utilizado por cualquier clase de stream. Para operaciones de archivo es posible utilizar FileStream, donde el buffering est ya incluido. Las clases ms relacionadas con la escritura y lectura de archivos (File Input/Output o File I/O) son: FileStream, cuyo propsito es lectura y escritura de datos binarios (no de texto legible), a cualquier archivo de tipo binario, aunque se puede utilizar para acceder a cualquier tipo de archivo, inclusive los de texto. StreamReader y StreamWriter, las cuales estn diseadas para lectura y escritura de archivos de texto. Estas clases se asumen como de un nivel ms alto que FileStream. Una observacin acerca de la declaracin de nombres/rutas de archivos en C#. Usualmente, la ruta de un archivo contiene el carcter \, que en C# se utiliza como caracter de control para smbolos especiales (como el cambio de lnea: \n). Sin embargo, entendiendo que no es el mismo sentido el que se le quiere dar en la interpretacin de rutas de archivos (por ej: C:\Mis documentos\Programas\ejemplo.cs), se utiliza una sintaxis particular, anteponiendo el smbolo @ antes del string con la ruta del archivo. Es decir: string rutaarchivo = @C:\Temp\archivo.txt; Esta declaracin evita la interpretacin de los dos caracteres \ como smbolos especiales y el string queda correctamente inicializado.

Using System.IO
Para el uso de estas clases, es necesario referenciar el uso del namespace System.IO, ya que System no contiene los elementos para el manejo de archivos. Por ello, los programas con acceso a archivos deben incluir la lnea: using System.IO; Constructores de StreamReader El ms simple de los constructores toma slo el nombre/ruta del archivo a abrir para lectura: StreamReader sr = new StreamReader(@C:\Temp\archivo.txt);

Sin embargo, reconociendo que hoy existen diferentes formatos (codificaciones) de archivos de texto y no solamente el tradicional formato ASCII, es factible establecer cul es la codificacin especial que este archivo de texto plano puede tener. Los formatos posibles son: ASCII, Unicode, UTF7, UTF8, BigEndianUnicode. El constructor ad-hoc es: StreamReader sr = new StreamReader(@C:\Temp\file.txt, Encoding.UTF8Encoding); En trminos prcticos, nos ser necesario recurrir a este tipo de codificaciones, ya que usualmente se trabajar con codificacin ASCII. El constructor deja abierto el stream para poder recuperar la informacin del archivo desde la instancia de StreamReader declarada. Para cerrar un stream o archivo, se invoca el mtodo Close(): sr.Close(); Lectura con StreamReader Son bsicamente tres los mtodos propios de StreamReader que permiten efectuar lectura desde el stream (archivo) declarado. ReadLine() Al igual que el conocido Console.ReadLine(), este mtodo lee una lnea completa de un archivo de texto hasta el cambio de lnea ms prximo. Al igual que su equivalente de consola, StreamReader.ReadLine() no incluye en el string el carcter de cambio de lnea. string linea = sr.ReadLine() ReadToEnd() Este mtodo, por su parte, se encarga de acumular la informacin que hay desde la lectura anterior (que pudo haberse hecho con ReadLine(), por ejemplo) hasta el final del archivo, todo en el mismo string. string linea = sr.ReadToEnd() Read () Finalmente, el mtodo simple Read() se encarga de leer un caracter a la vez, lo que permite procesar smbolo por smbolo el contenido del archivo. Convenientemente, este mtodo reconoce el cambio de lnea y se lo salta como si no existiese. Cuando se encuentra con el fin de archivo, retorna un valor 1, considerando que su retorno es siempre un int (y no un char). int SigCaracter = sr.Read(); Este mismo mtodo ofrece una declaracin alternativa (sobrecarga), donde es posible leer una cantidad especfica de caracteres y almacenarlos en un arreglo de enteros. char[] CharArray = new char[100]; int[] nChars = sr.Read(CharArray, 0, 100);

nChars es un arreglo con los enteros retornados por el mtodo, y ser menor si es que la cantidad de caracteres que quedan en el archivo es menor de 100. Escritura: StreamWriter Esta clase funciona prcticamente de la misma manera que StreamReader, excepto que su propsito es nicamente para escribir dentro de un archivo (u otro stream). Es relevante distinguir que en este caso, el proceso de apertura para escritura considera que: Si el archivo no existe lo crea vaco para comenzar a escribir.

escribir al final.

Constructores de StreamWriter El ms simple de los constructores toma slo el nombre/ruta del archivo a abrir para escritura. StreamWriter sw = new StreamWriter (@C:\Temp\archivo.txt); Este constructor asume por defecto el formato UTF8 de archivos planos, ya que es el manejado por .NET. Sin embargo, existe el constructor equivalente que permite abrir un archivo especificando otra codificacin de archivo plano, por ejemplo ASCII. StreamWriter sw = new StreamWriter (@C:\doc\file.txt, Encoding.ASCII); Un tercer constructor utiliza como segundo parmetro un boolean que indica si el archivo debe ser abierto para Agregar, es decir, en un modo Append. StreamWriter sw = new StreamWriter (@C:\Temp\archivo.txt, true); De la misma manera que en el caso de la lectura, para cerrar un stream o archivo, se invoca el mtodo Close: sw.Close();

Escritura con StreamWriter

Son bsicamente dos los mtodos propios de StreamWriter que permiten escribir hacia el stream (archivo) declarado y son los mismos que se usan para escribir en la consola: Write() y WriteLine(). WriteLine() Totalmente equivalente a Console.WriteLine(), se utiliza la misma idea, y el mismo formato, sabiendo que se estar escribiendo el texto no a la consola, sino que al stream abierto con el constructor. string linea = Texto de prueba; sw.WriteLine(linea);

sw.WriteLine(Los valores posibles son: {0} y {1}, 3, 5); Write () Tambin presente, el mtodo simple Write(), permite escribir texto en el stream, de la misma forma que su equivalente mtodo de la clase Console. En este caso se reconocen las siguientes alternativas de uso: Imprimir un string string linea = Texto de prueba; sw.Write(linea); Imprimir un caracter char caracter = T; sw.Write(caracter); Imprimir un arreglo de caracteres char[] caracteres = new char[100]; for(int i=0; i<100; i++) caracteres[i] = +; sw.Write(caracteres); Imprimir una porcin de un arreglo de caracteres char[] caracteres = new char[100]; for(int i=0; i<100; i++) caracteres[i] = +; sw.Write(caracteres, 25, 50); // Desde posicin 25 se escriben 50 caracteres

Ejemplos de Manejo de Archivos en C#

Crea un archivo secuencial
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <stdio.h> int main() { int cuenta; nombre de cuenta */ double saldo;

/* nmero de cuenta */ /* saldo de la cuenta */

char nombre[ 30 ]; /*

FILE *ptrCf; /* ptrCf = apuntador al archivo clientes.dat */ /* fopen abre el archivo. Si no es capaz de crear el archivo, sale del programa */ if ( ( ptrCf = fopen( "clientes.dat", "w" ) ) == NULL ) { printf( "El archivo no pudo abrirsen" ); } /* fin de if */ else { printf( "Introduzca la cuenta, el nombre, y el saldo.n" ); printf( "Introduzca EOF al final de la entrada.n" ); printf( "? " ); scanf( "%d%s%lf", &cuenta, nombre, &saldo ); /* escribe la cuenta, el nombre y el saldo dentro del archivo con fprintf */ while ( !feof( stdin ) ) {

23 fprintf( ptrCf, "%d %s %.2fn", cuenta, nombre, saldo ); 24 printf( "? " ); 25 scanf( "%d%s%lf", &cuenta, nombre, &saldo ); } /* fin de 26 while */ 27 28 fclose( ptrCf ); /* fclose cierra el archivo */ 29 } /* fin de else */ 30 return 0; /* indica terminacin exitosa */ 31 32 } /* fin de main */ 33

Leyendo desde un archivo de texto:

using System; using System.IO; static void Main(string[] args) { string fileName = "temp.txt"; FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read); StreamReader reader = new StreamReader(stream); while (reader.Peek() > -1) Console.WriteLine(reader.ReadLine()); reader.Close(); } using System; using System.IO; /// Permite leer un archivo /// <param name="sFileName">Nombre del archivo</param> Private void ReadFile(string sFileName) { string sPath = "c:\\folder\\"; string sFileName = sPath + "archivo.txt"; //verifico que exista el archivo if (File.Exists(sFileName)) { FileStream fs = new FileStream(sFileName,FileMode.Open, FileAccess.Read, FileShare.ReadWrite); StreamReader sr = new StreamReader(fs); //Leo toda la informacin del archivo string sContent = sr.ReadToEnd(); //cierro los objetos fs.Close(); sr.Close(); Response.Write("Contenido = " + sContent); } } static void Main(string[] args)

{ string sPath = "c:\\folder\\"; string sFileName = sPath + "archivo.txt"; ReadFile(sFileName); }

Lectura de un Archivo de Texto, mostrando contenido en pantalla:

using System; using System.IO; class Archivo { StreamReader sr; bool abierto = false; // Constructor: Recibe el nombre del archivo y lo abre (con control errores) public Archivo(string filename) { try { sr = new StreamReader(filename); abierto = true; } catch(Exception e) { Console.WriteLine("Error en la apertura de \"{0}\": {1}", filename, e.ToString()); } } public void Mostrar() { string linea; if(!abierto) return; // Si no se pudo abrir, no hay nada que leer linea = sr.ReadLine(); while(linea != null) { // Lee lneas mientras haya (mientras sean !=null) Console.WriteLine(linea); linea = sr.ReadLine(); } sr.Close(); abierto = false; }} static void Main(string[] args){ string nombre; Console.Write("Nombre del archivo: "); nombre = Console.ReadLine(); Archivo archivo = new Archivo(nombre); archivo.Mostrar(); Console.ReadLine(); }
Escribiendo en un archivo de texto:

using System; using System.IO; static void Main(string[] args)

{ string fileName = "temp.txt"; FileStream stream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write); StreamWriter writer = new StreamWriter(stream); writer.WriteLine("Esta es la primera lnea del archivo."); writer.Close(); }
Creando un archivo y escribiendo en este:

/*Este ejemplo usa el mtodo CreateText() el cual crea un Nuevo archive y retorna un objeto StreamWriter que escribe a un archivo usando formato UTF-8. */ using System; using System.IO; static void Main(string[] args) { string fileName = "temp.txt"; StreamWriter writer = File.CreateText(fileName); writer.WriteLine("Este es mi Nuevo archivo creado."); writer.Close(); } Insertando texto en un archivo: using System; using System.IO; static void Main(string[] args) { try { string fileName = "temp.txt"; // esto inserta texto en un archivo existente, si el archivo no existe lo crea StreamWriter writer = File.AppendText(fileName); writer.WriteLine("Este es el texto adicionado."); writer.Close(); } catch { Console.WriteLine("Error"); } } Ejemplo de Procesamiento de Operaciones Matemticas en Archivo: // Este ejemplo muestra cmo se procesa el contenido de un archivo, //que indica operaciones matemticas bsicas: * / + using System;

using System.IO; class Calculadora { StreamReader sr; bool abierto = false; // Constructor: Recibe el nombre del archivo y lo intenta abrir. // Si no puede abrirse para lectura, "abierto" queda como false public Calculadora(string filename) { try { sr = new StreamReader(filename); abierto = true; } catch(Exception e) { Console.WriteLine("Error en la apertura de \"{0}\": {1}", filename,e.ToString()); } } // Operacion: Recibe la operacin y dos nmeros en forma de string. // Retorna el resultado (int) de la operacin entre ambos nmeros. int Operacion(string op, string n1, string n2) { switch(op) { case "+": return( int.Parse(n1) + int.Parse(n2)); case "-": return( int.Parse(n1) - int.Parse(n2)); case "*": return( int.Parse(n1) * int.Parse(n2)); case "/": return( int.Parse(n1) / int.Parse(n2)); } return(0); } // Procesar: lee lneas del archivo abierto, procesando el contenido en forma de operaciones. // Observaciones: al finalizar se cierra el stream. No se valida el formato de c/lnea. public void Procesar() { string linea; string[] elementos; if(!abierto) return; // Si no se pudo abrir, no hay nada que leer linea = sr.ReadLine(); while(linea != null) { // Para poder usar Split(), las operaciones y los operandos deben // venir separados por espacios. elementos = linea.Split(); Console.WriteLine("{0} = {1}", linea, Operacion(elementos[1], elementos[0], elementos[2])); linea = sr.ReadLine(); } sr.Close(); abierto = false; }}

static void Main(string[] args) { string nombre; Console.Write("Nombre del archivo: "); nombre = Console.ReadLine(); Calculadora c = new Calculadora(nombre); c.Procesar(); Console.ReadLine(); }

Ejemplo de Ejecucin:
Tomando el siguiente archivo de operaciones calculos.txt: 4+4 5*6 8-2 6/3 Resulta el siguiente output: Nombre del archivo: calculos.txt 4+4=8 5 * 6 = 30 8-2=6 6/3=2
Ejemplo: Lectura y Escritura de un Archivo:

// Este ejemplo muestra cmo se procesa el contenido de un archivo, que //indica operaciones matemticas bsicas: * / + // Este ejemplo en particular, escribe el resultado en un archivo destino using System; using System.IO; class Calculadora { StreamReader sr; StreamWriter sw; bool abierto1 = false; bool abierto2 = false; // Constructor: Recibe el nombre del archivo y lo intenta abrir. // Si no puede abrirse para lectura, "abierto" queda como false // Si lo puede abrir, crea un segundo archivo con un nombre similar. public Calculadora(string filename) { try { sr = new StreamReader(filename); abierto1 = true; } catch(Exception e) { Console.WriteLine("Error en la apertura de \"{0}\": {1}",

filename,e.ToString()); } if(abierto1) { string nombrearchivo2; // Transforma "nombre.txt" en "nombre.out.txt" nombrearchivo2 = filename.Insert(filename.IndexOf('.'),".out"); try { sw = new StreamWriter(nombrearchivo2); abierto2 = true; } catch(Exception e) { Console.WriteLine("Error en la apertura de \"{0}\": {1}", nombrearchivo2,e.ToString()); }}} // Operacion: Recibe la operacin y dos nmeros en forma de string. // Retorna el resultado (int) de la operacin entre ambos nmeros. int Operacion(string op, string n1, string n2) { switch(op) { case "+": return( int.Parse(n1) + int.Parse(n2)); case "-": return( int.Parse(n1) - int.Parse(n2)); case "*": return( int.Parse(n1) * int.Parse(n2)); case "/": return( int.Parse(n1) / int.Parse(n2)); } return(0); } // Procesar: lee el archivo abierto, lnea por lnea, // procesando el contenido en forma de operaciones y escribiendo // el resultado en un segundo archivo. // Observaciones: Al finalizar se cierran los dos streams. // No se valida el formato de c/lnea. public void Procesar() { string linea, linea2; string[] elementos; // Si no se pudo abrir, no se podr leer ni escribir if(!abierto1 || !abierto2) return; Console.WriteLine("Procesando ..."); linea = sr.ReadLine(); while(linea != null) { elementos = linea.Split(); // ahora graba los resultados en el segundo archivo linea2 = linea + " = " + Operacion(elementos[1], elementos[0], elementos[2]).ToString(); sw.WriteLine(linea2); linea = sr.ReadLine(); } sr.Close(); abierto1 = false; sw.Close(); abierto2 = false;

Console.WriteLine("Listo"); }} static void Main(string[] args) { string nombre; Console.Write("Nombre del archivo: "); nombre = Console.ReadLine(); Calculadora c = new Calculadora(nombre); c.Procesar(); Console.ReadLine(); } Al abrir el archivo calculos.txt, se crea el archivo calculos.out.txt con el siguiente contenido: 4+4=8 5 * 6 = 30 8-2=6 6/3=2
Leyendo un archivo binario:

using System; using System.IO; static void Main(string[] args) { try { string fileName = "temp.txt"; int letter = 0; FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read); BinaryReader reader = new BinaryReader(stream); while (letter != -1) { letter = reader.Read(); if (letter != -1) Console.Write((char)letter); } reader.Close(); stream.Close(); } catch { Console.WriteLine("Error"); } }

Escribiendo en un archivo binario:

static void Main(string[] args) { try { string fileName = "temp.txt"; // data a ser guardada int[] data = {0, 1, 2, 3, 4, 5}; FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Write); BinaryWriter writer = new BinaryWriter(stream); for(int i=0; i<data.Length; i++) { // nmeros son guardados en formto UTF-8 format (4 bytes) writer.Write(data[i]); } writer.Close(); stream.Close(); } catch { Console.WriteLine("Error"); }

PHP
PHP es un lenguaje de programacin interpretado, diseado originalmente para la creacin de pginas web dinmicas. Se usa principalmente para la interpretacin del lado del servidor (server-side scripting) pero actualmente puede ser utilizado desde una interfaz de lnea de comandos o en la creacin de otros tipos de programas incluyendo aplicaciones con interfaz grfica usando las bibliotecas Qt o GTK+. PHP es un acrnimo recursivo que significa PHP Hypertext Preprocessor (inicialmente PHP Tools, o, Personal Home Page Tools). Fue creado originalmente por Rasmus Lerdorf en 1994; sin embargo la implementacin principal de PHP es producida ahora por The PHP Group y sirve como el estndar de facto para PHP al no haber una especificacin formal. Publicado bajo la PHP License, la Free Software Foundation considera esta licencia como software libre. Puede ser desplegado en la mayora de los servidores web y en casi todos los sistemas operativos y plataformas sin costo alguno. El lenguaje PHP se encuentra instalado en ms de 20 millones de sitios web y en un milln de servidores, el nmero de sitios en PHP ha compartido algo de su preponderante dominio con otros nuevos lenguajes no tan poderosos desde agosto de 2005. El sitio web de Wikipedia est desarrollado en PHP. Es tambin el mdulo Apache ms popular entre las computadoras que utilizan Apache como servidor web. El gran parecido que posee PHP con los lenguajes ms comunes de programacin estructurada, como C y Perl, permiten a la mayora de losprogramadores crear aplicaciones complejas con una curva de aprendizaje muy corta. Tambin les permite involucrarse con aplicaciones de contenido dinmico sin tener que aprender todo un nuevo grupo de funciones. Aunque todo en su diseo est orientado a facilitar la creacin de sitios webs, es posible crear aplicaciones con una interfaz grfica para el usuario, utilizando la extensin PHP-Qt o PHP-GTK. Tambin puede ser usado desde la lnea de rdenes, de la misma manera como Perl o Python pueden hacerlo; a esta versin de PHP se la llama PHP-CLI (Command Line Interface). Cuando el cliente hace una peticin al servidor para que le enve una pgina web, el servidor ejecuta el intrprete de PHP. ste procesa el script solicitado que generar el contenido de manera dinmica (por ejemplo obteniendo informacin de una base de datos). El resultado es enviado por el intrprete al servidor, quien a su vez se lo enva al cliente. Mediante extensiones es tambin posible la generacin de archivos PDF, Flash, as como imgenes en diferentes formatos. Permite la conexin a diferentes tipos de servidores de bases de datos tales como MySQL, PostgreSQL, Oracle, ODBC, DB2, Microsoft SQL Server, Firebird y SQLite.

PHP tambin tiene la capacidad de ser ejecutado en la mayora de los sistemas operativos, tales como Unix (y de ese tipo, como Linux o Mac OS X) y Microsoft Windows, y puede interactuar con losservidores de web ms populares ya que existe en versin CGI, mdulo para Apache, e ISAPI. PHP es una alternativa a las tecnologas de Microsoft ASP y ASP.NET (que utiliza C# y Visual Basic .NET como lenguajes), a ColdFusion de la empresa Adobe, a JSP/Java y a CGI/Perl. Aunque su creacin y desarrollo se da en el mbito de los sistemas libres, bajo la licencia GNU, existe adems un entorno de desarrollo integrado comercial llamado Zend Studio. CodeGear (la divisin de lenguajes de programacin de Borland) ha sacado al mercado un entorno de desarrollo integrado para PHP, denominado 'Delphi for PHP. Tambin existen al menos un par de mdulos para Eclipse, uno de los entornos ms populares.1

Evidentemente, la utilidad de fgets resulta ser mucho ms amplia. Podemos emplearla, por ejemplo, con archivos remotos para extraer las etiquetas meta o para muchas otras cosas que se nos puedan ocurrir. Aqu os proponemos el script:

<? function negrita($path,$cadena) { //Iniciamos la variable $texto = ""; //Abrimos el archivo en modo lectura $fp = fopen($path,"r"); //Leemos linea por linea el contenido del archivo while ($linea= fgets($fp,1024)) { //Sustituimos las ocurrencias de la cadena que buscamos $linea = str_replace($cadena,"<b>$cadena</b>",$linea); //Anadimos la linea modificada al texto $texto .= $linea; } return $texto; } //Definimos el path y la cadena $path="escribe el camino de acceso a tu archivo"; $cadena = "escribe tu cadena"; //Llamamos la funcion $texto = negrita ($path,$cadena); //Mostramos el texto echo $texto; ?>

Java
Java es un lenguaje de programacin orientado a objetos, desarrollado por Sun Microsystems a principios de los aos 90. El lenguaje en s mismo toma mucha de su sintaxis de C y C++, pero tiene un modelo de objetos ms simple y elimina herramientas de bajo nivel, que suelen inducir a muchos errores, como la manipulacin directa de punteros o memoria.Con respecto a la memoria, su gestin no es un problema ya que sta es gestionada por el propio lenguaje y no por el programador. Las aplicaciones Java estn tpicamente compiladas en un bytecode, aunque la compilacin en cdigo mquina nativo tambin es posible. En el tiempo de ejecucin, el bytecode es normalmente interpretado o compilado a cdigo nativo para la ejecucin, aunque la ejecucin directa por hardware delbytecode por un procesador Java tambin es posible. La implementacin original y de referencia del compilador, la mquina virtual y las bibliotecas de clases de Java fueron desarrollados por Sun Microsystems en 1995. Desde entonces, Sun ha controlado las especificaciones, el desarrollo y evolucin del lenguaje a travs del Java Community Process, si bien otros han desarrollado tambin implementaciones alternativas de estas tecnologas de Sun, algunas incluso bajo licencias de software libre. Entre diciembre de 2006 y mayo de 2007, Sun Microsystems liber la mayor parte de sus tecnologas Java bajo la licencia GNU GPL, de acuerdo con las especificaciones del Java Community Process, de tal forma que prcticamente todo el Java de Sun es ahora software libre (aunque la biblioteca de clases de Sun que se requiere para ejecutar los programas Java an no lo es).

[cdigo] Crear un archivo secuencial en Java

0tweetsretweet Continuando con los ejercicios correspondientes a la manipulacin de archivos en Java, vamos a ver un ejemplo en el que crearemos un archivo secuencial, usando la clase ObjectOutputStream .

El resultado

El cdigo
Tenemos la clase UIBanco.java, la cual contiene una GUI reutilizable para los ejemplos que vamos a ver ms adelante: ?

001 002 003 004 005 006 007 008 009 010 011 012 013

import java.awt.*; import javax.swing.*; public class IUBanco extends JPanel { // texto de las etiquetas para la GUI protected final static String nombres[] = { "Nmero de cuenta", "Primer nombre", "Apellido", "Saldo", "Monto de la transaccin" }; // componentes de GUI; protegidos para el acceso futuro de las subclases protected JLabel etiquetas[]; protected JTextField campos[]; protected JButton hacerTarea1, hacerTarea2; protected JPanel panelInternoCentro, panelInternoSur; protected int tamanio; // nmero de campos de texto en la GUI

014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054 055 056 057 058 059 060

// constantes que representan a los campos de texto en la GUI public static final int CUENTA = 0, PRIMERNOMBRE = 1, APELLIDO = 2, SALDO = 3, TRANSACCION = 4;

// Configurar GUI. El argumento miTamanio del constructor determina el nmero d // filas de componentes de GUI. public IUBanco( int miTamanio ) { tamanio = miTamanio; etiquetas = new JLabel[ tamanio ]; campos = new JTextField[ tamanio ]; // crear etiquetas for ( int cuenta = 0; cuenta < etiquetas.length; cuenta++ ) etiquetas[ cuenta ] = new JLabel( nombres[ cuenta ] ); // crear campos de texto for ( int cuenta = 0; cuenta < campos.length; cuenta++ ) campos[ cuenta ] = new JTextField(); // crear panel para distribuir etiquetas y campos panelInternoCentro = new JPanel(); panelInternoCentro.setLayout( new GridLayout( tamanio, 2 ) ); // adjuntar etiquetas y campos a panelInternoCentro for ( int cuenta = 0; cuenta < tamanio; cuenta++ ) { panelInternoCentro.add( etiquetas[ cuenta ] ); panelInternoCentro.add( campos[ cuenta ] ); } // crear botones genricos; sin etiquetas ni manejadores de eventos hacerTarea1 = new JButton(); hacerTarea2 = new JButton(); // crear panel para distribuir los botones y adjuntarlos panelInternoSur = new JPanel(); panelInternoSur.add( hacerTarea1 ); panelInternoSur.add( hacerTarea2 ); // establecer esquema de este contenedor y adjuntarle los paneles setLayout( new BorderLayout() ); add( panelInternoCentro, BorderLayout.CENTER ); add( panelInternoSur, BorderLayout.SOUTH ); validate(); // validar esquema } // fin del constructor // devolver referencia al botn de tarea genrico hacerTarea1 public JButton obtenerBotonHacerTarea1() { return hacerTarea1; }

061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101 102 103 104 105 106 107

// devolver referencia al botn de tarea genrico hacerTarea2 public JButton obtenerBotonHacerTarea2() { return hacerTarea2; } // devolver referencia al arreglo campos de objetos JTextField public JTextField[] obtenerCampos() { return campos; } // borrar el contenido de los campos de texto public void borrarCampos() { for ( int cuenta = 0; cuenta < tamanio; cuenta++ ) campos[ cuenta ].setText( "" ); }

// establecer valores de los campos de texto; lanzar IllegalArgumentException s // hay un nmero incorrecto de objetos String en el argumento public void establecerValoresCampos( String cadenas[] ) throws IllegalArgumentException { if ( cadenas.length != tamanio ) throw new IllegalArgumentException( "Debe haber " + tamanio + " objetos String en el arreglo" ); for ( int cuenta = 0; cuenta < tamanio; cuenta++ ) campos[ cuenta ].setText( cadenas[ cuenta ] ); }

// obtener arreglo de objetos String con el contenido actual de los campos de t public String[] obtenerValoresCampos() { String valores[] = new String[ tamanio ]; for ( int cuenta = 0; cuenta < tamanio; cuenta++ ) valores[ cuenta ] = campos[ cuenta ].getText(); return valores; } } // fin de la clase IUBanco

108 109 110 111 112 113 114

La clase RegistroCuentas.java representa un registro de informacin: ?

01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

import java.io.Serializable; public class RegistroCuentas implements Serializable { private int cuenta; private String primerNombre; private String apellidoPaterno; private double saldo;

// el constructor sin argumentos llama al otro constructor con valores predeterm public RegistroCuentas() { this( 0, "", "", 0.0 ); } // inicializar un registro public RegistroCuentas( int cta, String nombre, String apellido, double sald ) { establecerCuenta( cta ); establecerPrimerNombre( nombre ); establecerApellidoPaterno( apellido ); establecerSaldo( sald ); } // establecer nmero de cuenta public void establecerCuenta( int cta ) { cuenta = cta; } // obtener nmero de cuenta public int obtenerCuenta() { return cuenta; } // establecer primer nombre public void establecerPrimerNombre( String nombre ) { primerNombre = nombre; } // obtener primer nombre public String obtenerPrimerNombre() {

38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

return primerNombre; } // establecer apellido paterno public void establecerApellidoPaterno( String apellido ) { apellidoPaterno = apellido; } // obtener apellido paterno public String obtenerApellidoPaterno() { return apellidoPaterno; } // establecer saldo public void establecerSaldo( double sald ) { saldo = sald; } // obtener saldo public double obtenerSaldo() { return saldo; } } // fin de la clase RegistroCuentas

Por ltimo, la clase CrearArchivoSecuencial.java, que contiene el mtodo main, es donde hacemos el proceso de escritura de objetos secuencialmente en un archivo, mediante la clase ObjectOutputStream . ?

001 002 003 004 005 006 007

import java.io.*; import java.awt.*; import java.awt.event.*; import javax.swing.*; public class CrearArchivoSecuencial extends JFrame { private ObjectOutputStream salida; private IUBanco interfazUsuario; private JButton botonIntro, botonAbrir;

008 009 010 011 012 013 014 015 016 017 018 019 020 021 022 023 024 025 026 027 028 029 030 031 032 033 034 035 036 037 038 039 040 041 042 043 044 045 046 047 048 049 050 051 052 053 054

// configurar GUI public CrearArchivoSecuencial() { super( "Creacin de un archivo secuencial de objetos" ); // crear instancia de interfaz de usuario reutilizable interfazUsuario = new IUBanco( 4 ); // cuatro campos de texto getContentPane().add( interfazUsuario, BorderLayout.CENTER ); // configurar botn hacerTarea1 para usarlo en este programa botonAbrir = interfazUsuario.obtenerBotonHacerTarea1(); botonAbrir.setText( "Guardar en archivo ..." );

// registrar componente de escucha para llamar a abrirArchivo cuando se opri botonAbrir.addActionListener( // clase interna annima para manejar evento de botonAbrir new ActionListener() { // llamar a abrirArchivo cuando se oprima el botn public void actionPerformed( ActionEvent evento ) { abrirArchivo(); } } // fin de la clase interna annima ); // fin de la llamada a addActionListener // configurar botn hacerTarea2 para usarlo en este programa botonIntro = interfazUsuario.obtenerBotonHacerTarea2(); botonIntro.setText( "Introducir" ); botonIntro.setEnabled( false ); // deshabilitar botn

// registrar componente de escucha para llamar a agregarRegistro cuando se o botonIntro.addActionListener( // clase interna annima para manejar evento de botonIntro new ActionListener() { // llamar a agregarRegistro cuando se oprima el botn public void actionPerformed( ActionEvent evento ) { agregarRegistro(); } } // fin de la clase interna annima ); // fin de la llamada a addActionListener // registrar componente de escucha de ventana para manejar evento de cierre addWindowListener(

055 056 057 058 059 060 061 062 063 064 065 066 067 068 069 070 071 072 073 074 075 076 077 078 079 080 081 082 083 084 085 086 087 088 089 090 091 092 093 094 095 096 097 098 099 100 101

// clase interna annima para manejar evento windowClosing new WindowAdapter() {

// agregar registro actual en la GUI al archivo, despus cerrar el arc public void windowClosing( WindowEvent evento ) { if ( salida != null ) agregarRegistro(); cerrarArchivo(); } } // fin de la clase interna annima ); // fin de la llamada a addWindowListener setSize( 350, 180 ); setVisible( true ); } // fin del constructor de CrearArchivoSecuencial

// permitir al usuario especificar el nombre del archivo private void abrirArchivo() { // mostrar cuadro de dilogo de archivo, para que el usuario pueda elegir el JFileChooser selectorArchivo = new JFileChooser(); selectorArchivo.setFileSelectionMode( JFileChooser.FILES_ONLY ); int resultado = selectorArchivo.showSaveDialog( this );

// si el usuario hizo clic en el botn Cancelar del cuadro de dilogo, regre if ( resultado == JFileChooser.CANCEL_OPTION ) return;

File nombreArchivo = selectorArchivo.getSelectedFile(); // obtener archivo s // mostrar error si es invlido if ( nombreArchivo == null || nombreArchivo.getName().equals( "" ) ) JOptionPane.showMessageDialog( this, "Nombre de archivo invlido", "Nombre de archivo invlido", JOptionPane.ERROR_MESSAGE ); else { // abrir archivo try { salida = new ObjectOutputStream( new FileOutputStream( nombreArchivo ) ); botonAbrir.setEnabled( false ); botonIntro.setEnabled( true ); }

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148

// procesar excepciones que pueden ocurrir al abrir el archivo catch ( IOException excepcionES ) { JOptionPane.showMessageDialog( this, "Error al abrir el archivo", "Error", JOptionPane.ERROR_MESSAGE ); } } // fin de instruccin else } // fin del mtodo abrirArchivo // cerrar archivo y terminar la aplicacin private void cerrarArchivo() { // cerrar el archivo try { salida.close(); System.exit( 0 ); } // procesar excepciones que pueden ocurrir al cerrar el archivo catch( IOException excepcionES ) { JOptionPane.showMessageDialog( this, "Error al cerrar el archivo", "Error", JOptionPane.ERROR_MESSAGE ); System.exit( 1 ); } } // fin del mtodo cerrarArchivo // agregar registro al archivo public void agregarRegistro() { int numeroCuenta = 0; RegistroCuentas registro; String valoresCampos[] = interfazUsuario.obtenerValoresCampos(); // si el valor del campo cuenta no est vaco if ( ! valoresCampos[ IUBanco.CUENTA ].equals( "" ) ) { // escribir valores en el archivo try { numeroCuenta = Integer.parseInt( valoresCampos[ IUBanco.CUENTA ] ); if ( numeroCuenta > 0 ) { // crear nuevo registro registro = new RegistroCuentas( numeroCuenta, valoresCampos[ IUBanco.PRIMERNOMBRE ], valoresCampos[ IUBanco.APELLIDO ], Double.parseDouble( valoresCampos[ IUBanco.SALDO ] ) ); // escribir el registro y vaciar el bfer salida.writeObject( registro ); salida.flush(); }

149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195

else { JOptionPane.showMessageDialog( this, "El nmero de cuenta debe ser mayor que 0", "Nmero de cuenta incorrecto", JOptionPane.ERROR_MESSAGE ); } // borrar campos de texto interfazUsuario.borrarCampos(); } // fin de bloque try

// procesar formato invlido de nmero de cuenta o saldo catch ( NumberFormatException excepcionFormato ) { JOptionPane.showMessageDialog( this, "Nmero de cuenta o saldo incorrecto", "Formato de nmero incorrect JOptionPane.ERROR_MESSAGE ); }

// procesar excepciones que pueden ocurrir al escribir en el archivo catch ( IOException excepcionES ) { JOptionPane.showMessageDialog( this, "Error al escribir en el archivo "Excepcin de ES", JOptionPane.ERROR_MESSAGE ); cerrarArchivo(); } } // fin de instruccin if } // fin del mtodo agregarRegistro public static void main( String args[] ) { JFrame.setDefaultLookAndFeelDecorated(true); JDialog.setDefaultLookAndFeelDecorated(true); new CrearArchivoSecuencial(); } } // fin de la clase CrearArchivoSecuencial

196 197 198 199 200 201 202 203 204 205 206 207

Delphi XE2
Embarcadero Delphi, antes conocido como CodeGear Delphi, Inprise Delphi y Borland Delphi, es un entorno de desarrollo de software diseado para la programacin de propsito general con nfasis en la programacin visual. En Delphi se utiliza como lenguaje de programacin una versin moderna de Pascal llamada Object Pascal. Es producido comercialmente por la empresa estadounidense CodeGear (antes lo desarrollaba Borland), adquirida en mayo de 2008 por Embarcadero Technologies, una empresa del grupo Thoma Cressey Bravo, en una suma que ronda los 30 millones de dlares. En sus diferentes variantes, permite producir archivos ejecutables para Windows, GNU/Linux y la plataforma .NET. CodeGear ha sido escindida de la empresa Borland, donde Delphi se cre originalmente, tras un proceso que pretenda en principio la venta del departamento de herramientas para desarrollo [1]. Pues en pocas palabras este programa lo que hace es, a partir de una direccin de un archivo de texto (c:\file.txt por ejemplo) , lo abre, lo imprime en un objeto de tipo "memo" y al precionar el boton "Contar", te cuenta las vocales, consonantes, digitos, espacios en blanco, caracteres especiales y letras. Es un sencillo ejemplo que te ayudar a entender como se manejan los archivos secuenciales en Delphi. Aqu esta el codigo fuente:
PLAIN TEXT

DELPHI: 1. unit Unit1; 2. 3. interface 4. 5. uses 6. Windows, Messages, Controls, Forms, 7. Dialogs, StdCtrls; 8. 9. type 10. TForm1 = class(TForm) 11. Memo: TMemo; 12. archivo: TEdit; 13. Button1: TButton; 14. Button2: TButton; 15. Button3: TButton; 16. Button4: TButton; 17. Label1: TLabel; 18. Label2: TLabel; 19. Label3: TLabel; 20. Label4: TLabel; 21. Label5: TLabel; 22. Label6: TLabel;

SysUtils,

Variants, Classes,

Graphics,

23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. 55. 56. 57. 58. 59. 60. 61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76.

letras: TLabel; digitos: TLabel; blancos: TLabel; caracteres: TLabel; consonantes: TLabel; vocales: TLabel; procedure Button4Click(Sender: procedure Button3Click(Sender: procedure Button1Click(Sender: procedure Button2Click(Sender: private { Private declarations } public { Public declarations } end; var Form1: TForm1; implementation {$R *.dfm}

TObject); TObject); TObject); TObject);

procedure TForm1.Button4Click(Sender: TObject); begin form1.close end; procedure TForm1.Button3Click(Sender: TObject); begin archivo.Text:=''; letras.caption:=''; digitos.caption:=''; blancos.caption:=''; caracteres.caption:=''; vocales.caption:=''; consonantes.caption:=''; memo.Text:=''; memo.SetFocus; end; procedure TForm1.Button1Click(Sender: TObject); begin memo.Lines.LoadFromFile(archivo.text); end; procedure TForm1.Button2Click(Sender: TObject); var l,d,b,v,c,ce,a,band:integer; x:char; begin l:=0; d:=0; b:=0;

77. v:=0; 78. c:=0; 79. ce:=0; 80. a:=0; 81. 82. while a<>length(memo.Text) do 83. begin 84. band:=0; 85. a:=a+1; 86. x:=memo.text[a]; 87. 88. if x in ['A'..'Z','a'..'z','','','','','','','','','','','',''] then 89. begin 90. l:=l+1; 91. band:=1; 92. end; 93. 94. if x in ['0'..'9'] then 95. begin 96. d:=d+1; 97. band:=1; 98. end; 99. 100. if x=' ' then 101. begin 102. b:=b+1; 103. band:=1; 104. end; 105. 106. if x in ['a','e','i','o','u','A','E','I','O','U','','','','','','','','','',''] then 107. begin 108. v:=v+1; 109. band:=1; 110. end; 111. 112. if band=0 then 113. ce:=ce+1; 114. 115. end; 116. 117. letras.caption:=inttostr(l); 118. digitos.caption:=inttostr(d); 119. blancos.caption:=inttostr(b); 120. vocales.caption:=inttostr(v); 121. consonantes.caption:=inttostr(l-v); 122. caracteres.caption:=inttostr(ce); 123. end; 124. 125. end.
Y como veras, la linea clave para abrir el archivo es esta: PLAIN TEXT

DELPHI:

1. memo.Lines.LoadFromFile(archivo.text);
Y bueno espero y te sirva de algo :p aqu te dejo los archivos para que los descargues..

Read more: http://www.recursosdelweb.com/como-leer-archivos-secuenciales-en-delphi/#ixzz1mbkUohbG

http://es.kioskea.net/contents/langages/langages.php3 http://es.scribd.com/doc/15270823/LENGUAJES-DE-PROGRAMACION-para-elspace http://miparadigma-iucesmag.blogspot.com/2011/02/desventajas-de-laprogramacion.html http://es.wikipedia.org/wiki/Java_(lenguaje_de_programaci%C3%B3n) http://html.rincondelvago.com/ficheros-en-los-lenguajes-deprogramacion.html http://html.rincondelvago.com/informatica-documental.html http://unefa.edu.ve/serviciostecnologicos/images/stories/Pdservicios/varios/manejo%20de%20archivos%20en%20lenguaje%20c.pdf http://es.scribd.com/doc/29225934/14/Archivos-secuenciales http://todojava.awardspace.com/ejemplosjava.html?desc=LeerArchivoSecuencial http://todojava.awardspace.com/ejemplos-java.html http://casidiablo.net/uso-del-objectoutputstream-java/ http://es.wikipedia.org/wiki/Embarcadero_Delphi http://www.recursosdelweb.com/como-leer-archivos-secuenciales-en-delphi/