CENTRO UNIVERSITARIO SIGLO XXI

NOMBRE DEL ALUMNO:

ANTONIO CONCHA GARCIA.

NOMBRE DEL PROFESOR:

LUIS ALBERTO VARGAS CRUZ.

ASIGNTURA:

PRINCIPIOS DE LA PROGRAMACIÒN.

CARRERA:

INGIENERIA PETROLERA

CUATRIMESTRE:

7 TMO.

CUNDUACAN TAB. A 15 DE OCT. DEL 2021

1
 INDICE

INTRODUCCION. ................................................................................................................... 3
Archivos. ...................................................................................................................................... 4
Tipos de Archivo. ..................................................................................................................... 6
Funciones de entrada/salida .................................................................................................. 7
Opciones para formato de archivos ..................................................................................... 19
CONCLUSION. ...................................................................................................................... 23
BIBLIOGRAFIA...................................................................................................................... 24

2
 INTRODUCCION.

Los programas de ejemplo desarrollados en entradas anteriores han utilizado

hasta ahora, a la memoria principal tanto para su ejecución como para el
almacenamiento de los datos que administran; sin embargo, una vez que los
procesos terminan su ejecución, los datos leídos, procesados y utilizados por ellos
desaparecen, y en muchas situaciones es conveniente, tanto preservar los datos
como obtener grandes cantidades de ellos como entrada para los procesos. Para
estos casos, el manejo de archivos resulta un elemento clave.

Definición y conceptos.

Un archivo es, de manera general, un conjunto de bytes relacionados entre sí y

referidos por un nombre.

Dependiendo del esquema de almacenamiento utilizado, el conjunto

de bytes puede estar agrupado en sectores como en el caso de los discos duros
por ejemplo. Los sectores pueden ser de distintos tamaños y dependen tanto de la
geometría del disco, como de la configuración del Sistema Operativo.

Los archivos son el esquema más conveniente de preservación de datos más allá
de la vida de un proceso, y también sirven como medio de comunicación entre los
procesos que se ejecutan en una computadora.

En la entrada Consideraciones respecto a la Entrada y Salida (E/S) de Procesos,

se mencionaron los tres tipos de archivos o flujos asociados a los
procesos: stdin, stdout y stderr. En las siguientes entradas se presentará cómo
asociar más archivos, representados por su respectivo flujo, a sus programas.

3
Archivos.

La información de un ordenador está almacenada en lo que se llaman archivos.

Normalmente los archivos están formados por un nombre, un punto y una
extensión (p.e. PROGRAMA.EXE).

El nombre nos sirve para diferenciar unos archivos de otros y la extensión para
atribuirle unas propiedades concretas.

Estas propiedades asociadas o "tipo de archivo" vienen dadas por las letras que
conforman la extensión.

Normalmente su máximo son tres letras aunque existen algunas excepciones

(.jpeg, .html, .java, etc.). Cada uno de estos pequeños grupos de caracteres está
asociado a un tipo de archivo.

Todos los datos que un programa utiliza durante su ejecución se encuentran en

sus variables, que están almacenadas en la memoria RAM del computador.

La memoria RAM es un medio de almacenamiento volátil: cuando el programa

termina, o cuando el computador se apaga, todos los datos se pierden para
siempre.

Para que un programa pueda guardar datos de manera permanente, es necesario

utilizar un medio de almacenamiento persistente, de los cuales el más importante es
el disco duro.

4
Los datos en el disco duro están organizados en archivos. Un archivo es una
secuencia de datos almacenados en un medio persistente que están disponibles
para ser utilizados por un programa. Todos los archivos tienen un nombre y una
ubicación dentro del sistema de archivos del sistema operativo.

Los datos en un archivo siguen estando presentes después de que termina el

programa que lo ha creado. Un programa puede guardar sus datos en archivos
para usarlos en una ejecución futura, e incluso puede leer datos desde archivos
creados por otros programas.

Un programa no puede manipular los datos de un archivo directamente.

Para usar un archivo, un programa siempre abrir el archivo y asignarlo a una

variable, que llamaremos el archivo lógico. Todas las operaciones sobre un
archivo se realizan a través del archivo lógico

Dependiendo del contenido, hay muchos tipos de archivos. Nosotros nos

preocuparemos sólo de los archivos de texto, que son los que contienen texto, y
pueden ser abiertos y modificados usando un editor de texto como el Bloc de
Notas. Los archivos de texto generalmente tienen un nombre terminado en .txt.

5
Tipos de Archivo.

Podemos dividir los archivos en dos grandes grupos. Éstos son los ejecutables y
los no ejecutables o archivos de datos. La diferencia fundamental entre ellos es
que los primeros están creados para funcionar por sí mismos y los segundos
almacenan información que tendrá que ser utilizada con ayuda de algún programa.

De todos modos, la mayoría de los programas llevan otros archivos que resultan
necesarios aparte del ejecutable. Estos archivos adjuntos que requieren los
programas son necesarios para su buen funcionamiento, y aunque puedan tener
formatos distintos no pueden ser separados de su programa original. O al menos
si queremos que siga funcionando bien.

Dentro de los tipos de archivos de datos se pueden crear grupos, especialmente

por la temática o clase de información que guarden. Así lo haremos en este
tutorial. Separaremos los grupos en archivos de imágenes, de texto, de vídeo,
comprimidos... y nombraremos algunos programas asociados.

Los tipos de archivo más comunes son:

 De texto: txt, doc, docx, etc.

 De imagen: jpg, gif, bmp, png, etc.

 De vídeo: avi, mp4, mpeg, mwv, etc.

 De ejecución o del sistema: exe, bat, dll, sys, etc.

 De audio: mp3, wav, wma, etc.

 De archivo comprimido: zip, rar, tar, etc.

 De lectura: pdf, epub, azw, ibook, etc.

 De imagen de disco: iso, mds, img, etc.

6
Funciones de entrada/salida

Se trata de archivos ubicados en la memoria interna del dispositivo y con acceso

de lectura y escritura. Para lo cual se propone obtener los datos de un control
EditText para ser grabados en el archivo y un control TextView para visualizar los
datos desde el archivo. Las acciones se fundamentan en tres controles Button:
para grabar datos en el archivo, leer datos del archivo y finalizar la aplicación.

Figura 1: Dando nombre a la aplicación.

Paso 0. Le damos el nombre a la aplicación “ArchivoIO” (Figura 1), y aceptamos

los demás parámetros sugeridos por el asistente hasta el final.

Paso 1. Podemos señalar el control TextView, creado por defecto, para suprimirlo
y comenzar la interface gráfica sin controles.

7
Paso 2. Con el fin de obtener el dato a ser guardado en el archivo, colocamos para
el título y su campo correspondiente, una pareja de controles TextView y EditText,
ubicados en la pestañas Text Fields y Form Widgets respectivamente (dentro de la
gama de dominios de los controles EditText, seleccionamos el que acepta texto).
En la carpeta Outline, podemos observar los nombres “textView1” y “editText1”
dado a los controles por defecto (Figura 2). Asignamos la propiedad:

Al control “textView1”, propiedad Text: Le damos el texto “Nombre:”.

Figura 2: Ubicando controles.

8
Paso 3. Ubicamos sobre la interface gráfica, 3 controles Button, situados en la
pestaña Form Widgets, asociados a las acciones de grabar y leer datos del
archivo, y salir de la aplicación (Figura 2). Asignamos las propiedades:

Al control “button1”, propiedad Text: Le damos el texto “Grabar”.

Control “button1”, propiedad On Click: nombre del método a ejecutar “grabar”.
Control “button2”, propiedad Text: Le damos el texto “Leer”.
Control “button2”, propiedad On Click: nombre del método a ejecutar “leer”.
Control “button3”, propiedad Text: Le damos el texto “Salir”.
Control “button2”, propiedad On Click: nombre del método a ejecutar “salir”.

Paso 4. Situamos un TextView (Figura 2), ubicado en la pestaña Form Widgets,

para reportar los datos obtenidos del archivo. En la carpeta Outline, podemos
observar los nombres “textView2” dado al control por defecto. Asignamos la
propiedad:

Al control “textView2”, propiedad Text: Le damos el texto “Datos del archivo:”

9
Paso 5. Salvar el trabajo elaborado, ésta acción puede ser realizada regularmente.

Figura 3: Mostrando emulador con aplicación.

Paso 6. Podemos, opcionalmente, ejecutar la aplicación, usando el menú Run o

ubicando sobre la aplicación “ArchivoIO”, obtener el menú contextual (clic
derecho), seleccionar Run As y posteriormente Android Application (Figura 3). Por
supuesto, la aplicación registra error al hacer uso de los botones por faltar la
codificación de los métodos correspondientes. Para ello pasamos a trabajar sobre

10
el archivo fuente Java. Para seguir trabajando no es necesario cerrar el emulador,
se sugiere minimizarlo.

Paso 7. Damos doble clic sobre el archivo fuente “MainActivity.java”, ubicado en la

carpeta Package Explorer (Figura 4).

Figura 4: Declarando controles.

Paso 8. Declaramos el control EditText donde el usuario registra el dato a grabar y

el control TextView para depositar el dato obtenido del archivo (Figura 4). No es
necesario que tengan el mismo nombre dado en la interface de usuario.
El IDE determina como error el uso de las clases EditText y TextView, por no
haber sido importadas, se corrige, al construir la sentencia correspondientes, para
lo cual se puede utilizar la directiva Ctrl + Shift + O (o al utilizar la ayuda en línea
con Ctrl + Barra espaciadora).

Paso 9. Enlazar y hacer corresponder, las referencias declaradas, con los

identificadores ubicados en la interface gráfica en el ambiente XML (Figura 4).

11
Para lo cual se utiliza el método findViewById(), que recibe como argumento, el
identificador del control utilizado en el ambiente XML, obtenido de
“/gen/com.example.archivoio/R.java”.

Paso 10. Codificamos en la clase MainActivity, los métodos grabar(), leer() y salir()
(Figura 5), asociados a los botones a ser ejecutados por el usuario.

Figura 5: Codificando métodos.

12
Recuerde importar las clases View, Context, Toast, BufferedReader,
InputStreamReader, OutputStreamWrite e IOException; para lo cual se puede
utilizar la directiva Ctrl + Shift + O (o al utilizar la ayuda en línea con Ctrl + Barra
espaciadora).

Los mensajes son reportados mediante la clase Toast, la cual es explicada en un

apartado anterior. Las sentencias correspondientes a la apertura, la grabación y el
cerrado del archivo se ubican en un bloque try.

En el método grabar(), se valida el dato del EditText y se aplica la sentencia:

OutputStreamWriter osw=new OutputStreamWriter (openFileOutput ("datos.txt",

Context.MODE_PRIVATE));

La cual produce la apertura del archivo, utilizando la clase OutputStreamWrite del

paquete java.io, la cual administra la referencia al flujo de salida asociado al
archivo, retornado por el método openFileOutput(), método que consta de 2
argumentos:
• El primero se refiere al identificador del archivo. Para el caso “datos.txt”.
• El segundo representa el modo de acceso al archivo, “Context.MODE_PRIVATE”
admite el acceso únicamente por la aplicación.
Posteriormente, se graba el dato mediante el método write(), de la clase
OutputStreamWrite y finalmente se cierra el archivo invocando el método close().

En el método leer(), se aplica la sentencia:

BufferedReader br=new BufferedReader( new InputStreamReader(

openFileInput("datos.txt")));

La cual causa la apertura del archivo, utilizando las clases BufferedReader e

InputStreamReader del paquete java.io, para administrar la referencia al flujo de
entrada asociado al archivo, retornado por el método openFileInput(), método
solicita el argumento que hace referencia al identificador del archivo. Para el caso
“datos.txt”.
13
Para hacer la lectura de los datos del archivo, se utiliza el método readLine(), que
hace parte de la clase BufferedReader y al final, se cierra el archivo invocando el
método close().

Dentro del método salir(), solo es invocado el método finish(), con el fin de
terminar la ejecución de la actividad.

Paso 11. Los archivos se almacenan en la siguiente ubicación:

“/data/data/com.example.archivoio/files”, observable desde el DDMS. Puede

observar el archivo “datos.txt”, por la carpeta “File Explorer” del DDMS (Figura 6),
como se indica en el apartado de preferencias.

En la perspectiva DDMS, Es posible descargar el archivo, dando clic al botón con

ícono de salvar “pull”, igualmente se puede subir el archivo al dispositivo mediante
el botón con el ícono de cargar “push” (Figura 6).

Figura 6: Mostrando archivo de la perspectiva.

14
El código fuente del programa MainActivity.java, se puede observar a
continuación:
package com.example.archivoio;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.view.Menu;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends Activity {

private EditText editText1;
private TextView textView2;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
editText1=(EditText)findViewById(R.id.editText1);
textView2=(TextView)findViewById(R.id.textView2);
}

public void grabar(View v)

{ String s=editText1.getText().toString().trim();
if(s.equals(""))
Toast.makeText(this,"Faltan datos",Toast.LENGTH_LONG).show();

15
else
try
{ OutputStreamWriter osw=new
OutputStreamWriter(openFileOutput("datos.txt",Context.MODE_PRIVATE));
osw.write(s);
osw.close();
Toast.makeText(this,"Dato grabado",Toast.LENGTH_LONG).show();
}
catch(IOException e)
{ Toast.makeText(this,"Falta dato",Toast.LENGTH_LONG).show();
}
}
public void leer(View v)
{ try
{ BufferedReader br=new BufferedReader(new
InputStreamReader(openFileInput("datos.txt")));
textView2.setText(br.readLine());
br.close();
}
catch(IOException e)
{ Toast.makeText(this,"Error en archivo",Toast.LENGTH_LONG).show();
}
}
public void salir(View v)
{ finish();
}

@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.main, menu);

16
return true;
}

Figura 7: Mostrando emulador con aplicación final.

17
Paso 12. Ejecutar de nuevo la aplicación (Figura 7), no sin antes, salvar el trabajo
realizado (Ctrl + S). Se recomienda realizar las pruebas básicas y la de los
posibles de errores.

18
Opciones para formato de archivos

Las extensiones de archivo sirven para que Windows identifique de qué tipo es un
archivo y por tanto qué se puede hacer con él. Así, si un archivo requiere de una
aplicación para abrirse Windows le asignará un programa apropiado por defecto
para abrirlo y usarlo.

De esta forma si un archivo tiene la extensión .docx Windows lo identifica por

defecto como un documento de Microsoft Word (Siempre y cuando tengamos la
aplicación Microsoft Word instalada).

Un archivo con extensión .avi Windows lo identificará como un archivo de vídeo y

le asignará la aplicación que usemos por defecto para reproducir este tipo de
vídeos, como puede ser el reproductor VLC. Podemos conocer más sobre las
extensiones y tipos de los archivos.

En Windows XP, Windows 7, Windows 8 y Windows 10 y en adelante, la extensión

de los archivos viene oculta por defecto. Normalmente esto no es un problema ya
que no necesitamos conocer la extensión de un archivo para poder utilizarlo,
siempre y cuando Windows ya haya asignado una aplicación para ello o bien
sepamos con qué programa lo tenemos que abrir.

Generalmente Windows ya le asigna el icono del programa con el que se abrirá

por defecto para facilitarlo.

19
En los casos en que dispongamos de un archivo de algún tipo poco habitual en
que no dispongamos en nuestro ordenador de ninguna aplicación para su apertura
por defecto Windows dejará el icono del archivo en blanco. No obstante, en estos
casos Windows no oculta la extensión del archivo y la deja visible (son las letras
que salen después del último punto en el nombre de archivo).

20
Pongamos por ejemplo un archivo llamado "DOCUMENTO.TXT", su nombre será
DOCUMENTO y su extensión TXT. Esta extensión esta asociada con los tipos de
archivos que contienen texto, por lo tanto podemos suponer que habrá algo escrito
dentro. Nuestro sistema operativo (Windows en este caso) tendrá una lista de los
programas con los que puede ser utilizado este archivo y si deseamos visualizarlo
éste será abierto con el NotePad o Bloc de Notas.

Sin embargo, probablemente nos ocurrirá el problema de que si exploramos un

directorio o carpeta sólo veamos DOCUMENTO (sin el .TXT detrás). Se debe a
que Windows oculta las extensiones de los archivos. Esto es algo peligroso por el
hecho de que hay tipos de archivos que son potenciales contenedores de virus, y
si no conocemos su extensión no lo sabremos. Para que Windows nos muestre las
extensiones de todos los tipos de archivos iremos al Explorador de Windows y en
el menú Herramientas accederemos a las opciones de carpeta. En la nueva

21
ventana señalaremos la pestaña Ver y en la lista desmarcaremos la opción
"Ocultar las extensiones de archivo para los tipos de archivo conocidos".
Ya que estamos en las opciones de carpeta, la siguiente pestaña "Tipos de
Archivo" nos será muy útil. En ella se almacena la lista de diferentes extensiones
que Windows reconoce y con que programa están asociadas. Desde ella podemos
cambiar todas sus propiedades.

Marcando en la lista el tipo de archivo que nos interese y con el botón Cambiar
podremos escoger que sea ejecutado por otro programa distinto. En las Opciones
Avanzadas podremos seleccionar también el icono con el que aparezca y las
acciones posibles.

22
 CONCLUSION.

Los archivos son vitales y más que necesarios para las personas, las
organizaciones y la sociedad en general porque sin ellos no tendrían ni pasado ni
futuro. Vivirían al día sin tener conocimiento alguno sobre sus actuaciones o la de
los demás. Todo el mundo quiere conocer su historia y reclama estar informado y
documentado, pero no todo el mundo presta el interés que se merecen los
archivos para conseguir este conocimiento.

Y es que los archivos son necesarios en la sociedad porque promueven el

conocimiento, custodian y preservan nuestra memoria, difunden nuestro
patrimonio histórico, dan acceso a los ciudadanos, son garantía de Protección de
datos y Propiedad Intelectual, impulsan la investigación histórica y científica,
apoyan la gestión documental de las organizaciones, apoya a la transparencia y a
la rendición de cuentas, además dan agilidad en la localización de la
información…

23
 BIBLIOGRAFIA.

http://soda.ustadistancia.edu.co/enlinea/programacionmovil/archivos_de_entrada_
y_salida.html

https://www.geeknetic.es/Guia/91/Los-archivos-tipos-extensiones-y-programas-
para-su-uso.html

http://progra.usm.cl/apunte/materia/archivos.html

24