Proyecto#1 Manejo de Archivos

REPUBLICA DE PANAMA
CENTRO REGIONAL UNIVERSITARIO

DE VERAGUAS
LABORATORIO SEMANA #7
“MANEJO DE ARCHIVOS”
PROGRAMACION III
PROFESROR: DIEGO SANTIMATEO
INTEGRANTES:
FERNANDO VILLARREAL
6-711-1562
NORBERTO DELGADO
9-731-110
SEMESTRE: II
AÑO LECTIVO: 2008

INTRODUCCION
En el siguiente laboratorio veremos la funcionabilidad del lenguaje java respecto a la

creación de directorios, subdirectorios y manejo de archivos mediante un código.
Java es un lenguaje rico en recursos para manejar estructuras de datos, lo cual a nivel
superficial se ha podido experimentar con las diversas clases y métodos de manejo de
archivo.
Utilizaremos la clase File que nos proporciona información acerca de los archivos, de sus
atributos, de los directorios, etc.
Mediante la clase File podemos crear archivos, eliminarlos, cambiar su nombre, saber todo
lo relacionado con ellos y trabajarlos a nuestros gustos mediante los métodos que ella nos
ofrece.
Este laboratorio esta relacionado estrictamente con la clase File y la manera de utilizarla
para llevar a cabo algún propósito definido.
DESCRIPCIÓN DEL PROBLEMA
Se desea construir una aplicación Java, lo que significa que deben diseñarse las clases
necesarias para resolver el problema, recuerde que el main () solo controla la ejecución. La
aplicación debe permitir la creación de un documento HTML dentro de una carpeta que está
contenida en otra. Los nombres de los directorios y del documento deben ser capturados
desde el teclado. Se debe permitir la modificación de los contenidos de los elementos titulo,
p, li, h1,h2 y posibilidad de incluir hr dentro de un párrafo, los li y los p se pueden
discriminar usando un identificador id o name. No es necesario que los párrafos sean muy
extensos.
La aplicación debe verificar si el archivo se está creando en un subdirectorio y si el nombre

del archivo no existe en el directorio. Este trabajo se puede realizar en grupo no menores de
dos y no mayores de tres personas, solo en el caso de número impar. Se entrega y sustenta
en el laboratorio de la próxima semana. Entregue el informe impreso.
CODIGO FUENTE
CLASE DEL MAIN
import java.io.*;
import javax.swing.JOptionPane;
class Proyecto
{
public static void main(String args[])throws IOException
{
int opcion=0;
String ruta1,ruta2,ruta3,cadena;
/************* Instancias de objetos ****************/
Subdirectorio objeto1=new Subdirectorio();
Archivo objeto2=new Archivo();
Esquema objeto3=new Esquema();
/****************************************************/
try
{
while(opcion!=6)
{
cadena=JOptionPane.showInputDialog(null,"MENU DEL PROGRAMA\n\nCODIGO 1
==> CREAR LOS DIRECTORIOS\nCODIGO 2 ==> CREAR EL ARCHIVO\nCODIGO 3
==> MOSTRAR DATOS DEL ARCHIVO\nCODIGO 4 ==> MOSTRAR EL ARCHIVO
EN PANTALLA\nCODIGO 5 ==> MODIFICAR EL ARCHIVO\nCODIGO 6 ==> SALIR
DE PROGRAMA\n\nQUE DESEA REALIZAR");
opcion=Integer.parseInt(cadena);
switch(opcion)
{
case 1:
objeto1.crea();
ruta1=objeto1.devuelve_ruta();
JOptionPane.showMessageDialog(null,
"La ruta del subdirectorio es ==> "+ruta1+"",
"Salida",
JOptionPane.INFORMATION_MESSAGE);
break;
case 2:
objeto2.crea2(ruta1);
objeto3.crea3(ruta2);
"La ruta del archivo es ==> "+ruta2+"",
"Salida",
break;
case 3:
objeto2.datos(ruta2);
break;
case 4:
objeto2.muestra(ruta2);
break;
case 5:
ruta3=objeto3.modifica(ruta1,ruta2);
objeto2.Guarda_ruta(ruta3);
break;
case 6:
"Ha salido del programa !!!!",
"Salida",
break;
default:
"Eliga una opcion valida del menu",
"Salida",
JOptionPane.ERROR_MESSAGE);
break;
}
}
}
catch(Exception e)
{
"Error en la captuta de los datos",
"Salida",
}
}
}
Descripción:
La clase principal nos controla la ejecución de las demás clases mediante un menú el cual le
indica al usuario la manera de cómo elegir dichas clases ,es decir, le indica al usuario que es
lo que desea hacer.
Primero instanciamos tres objetos para relacionarlos con sus clases respectivamente:
Objeto1  Relacionado con la clase Subdirectorio.
Objeto2  Relacionado con la clase Archivo.
Objeto3  Relacionado con la clase Esquema.
Cada clase posee métodos y algunas de ellas un atributo que será explicado posteriormente.
Al elegir el usuario la opción 1 se invoca automáticamente el método crea de la clase

Subdirectorio la cual es la encargada de crear los directorios. Si se crean bien los directorios
se guarda la ruta o path en el atributo ruta1 de dicha clase y luego en el main se invoca al
método devuelve_ruta de la misma clase para que nos retorne la ruta de los directorios para
imprimirla en pantalla.
Al elegir el usuario la opción 2 se invoca automáticamente el método que nos devuelve la

ruta de los directorios (devuelve_ruta) de la clase Subdirectorio la cual se le asigna a una
variable de tipo String en el main para ser pasada por argumento al método crea2 de la clase
Archivo la cual nos crea el archivo y de está manera controlamos que el archivo quede
adentro de las dos carpetas. Si se crea bien hacemos lo mismo que en la clase Subdirectorio,
invocamos luego al método devuelve_ruta que nos retorna la ruta al main para ser asignada
a una variable la cual se pasa por argumento al método crea3 de la clase Esquema la cual
nos crea el esqueleto del archivo html. La ruta del archivo se imprime en pantalla en el
main.
Al elegir el usuario la opción 3 se invoca al método devuelve_ruta de la clase Archivo que

nos retorna la ruta completa del archivo al main, se la asignamos a una variable y se la
pasamos por argumento al método datos de la misma clase que nos imprime en pantalla los
datos del archivo como su nombre, su tamaño, su camino etc.
Al elegir el usuario la opción 4 se hace lo mismo que en la opción 3 solo que se invoca al
método muestra de la misma clase que nos imprime el archivo en sí línea por línea.
Al elegir el usuario la opción 5 se retornan las rutas tanto de los directorios como el del
archivo al main, cada una se le asigna a una variable y se invoca al método modifica
pasándole por argumento las dos rutas. Este método nos crea un nuevo archivo por tanto era
necesario la ruta de los directorios para guardarlo en la misma ruta que el archivo que
contenía solo el esqueleto. El archivo viejo se abre como lectura y el nuevo como escritura,
este método lee las líneas del archivo viejo y las imprime en el archivo nuevo (solo aquellas
que no deben ser cambiadas y aquellas que sí, se leen desde el teclado y se imprimen en el
archivo nuevo (no se leen del archivo viejo)). Luego se elimina el archivo viejo y se retorna
la ruta del archivo nuevo al main, se le asigna a una variable y se pasa por argumento al
método Guarda_ruta de la clase Archivo que guarda la ruta del nuevo archivo en el atributo
de la clase Archivo para disponer de todos los métodos con el nuevo archivo.
Y la opción 6 que es para salir del programa.

VARIABLES IMPORTANTES UTILIZADAS EN EL MAIN
VARIABLE DESCRIPCION
Esta variable nos guarda la opción que

el usuario elige del menú del programa y
opcion se usa un switch para elegir entre las
distintas posibilidades a la hora de
invocar a las clases con sus métodos.
Variables que guardan las rutas

retornadas de los métodos devuelve_ruta
Ruta1,ruta2,ruta3 de las clases Subdirectorio, Archivo y
Esquema.
La cadena nos guarda datos de tipo

String como la opción que elige el
cadena usuario del menú que luego se
transforma a entero para asignárselo a
opción.
CLASE SUBDIRECTORIO
import java.io.*;
class Subdirectorio
{
String ruta1;
/***********************************************************************/
public void crea()throws IOException
{
int sw=0;
String destino;
String dir1;
String dir2;
while(sw==0)
{
destino=JOptionPane.showInputDialog(null,
"Ingrese el destino de los directorios",
"Entrada",
JOptionPane.QUESTION_MESSAGE);
dir1=JOptionPane.showInputDialog(null,
"Ingrese el nombre del directorio principal",
"Entrada",
dir2=JOptionPane.showInputDialog(null,
"Ingrese el nombre del subdirectorio",
"Entrada",
File archivo1=new File(""+destino+"\\"+dir1+"\\"+dir2+"");
if(archivo1.mkdirs())
{
"El directorio fue creado",
"Salida",
sw=1;
this.ruta1=archivo1.getAbsolutePath();
}
else
{
if(archivo1.canWrite())
{
"El directorio ya existe, pruebe otro nombre",
"Salida",
}
else
{
"El destino del directorio no es valido, pruebe otro !!!",
"Salida",
}
}
}
}
/***********************************************************************/
public String devuelve_ruta()
{
return(ruta1);
}
}
/***********************************************************************/
Descripción:
La clase subdirectorio es la encargada de crear los directorios, el principal y el secundario el

cual está dentro del principal y contendrá el archivo html. Contiene o posee un atributo
llamado ruta1 en el cual se guardara la ruta de los dos directorios para a la hora de crear el
archivo html está ruta sirva para controlar que el archivo se cree dentro de los dos
directorios.
Esta clase posee dos métodos:
El método crea: El cual pide la ruta donde el usuario desea crear los directorios y los
nombres de dichos directorios. También se encarga de controlar que la ruta especificada por
el usuario sea correcta y que el directorio secundario no exista en el principal a la hora de
crearlo. Si el subdirectorio se crea correctamente se guarda la ruta de los directorios en el
atributo ruta1.
El método devuelve _ ruta: Con este método podemos tener acceso a la ruta de los
directorios en cualquier momento del programa y es muy importante a la hora de crear el
archivo html ya que solo se invoca y con toda seguridad a la hora de crear el archivo, se
guardara dentro de los dos directorios.
VARIABLES IMPORTANTES UTILIZADAS EN LA CLASE
SUBDIRECTORIO
Esta variable controla un ciclo while que

nos sirve para controlar o verificar que
Sw el usuario cree bien o no el directorio.
Si lo crea bien salimos del ciclo
cambiándole el valor, si no seguimos en
el mismo procedimiento hasta que el
usuario de una entrada válida.
Destino Esta variable nos guarda el destino de

los directorios ya sea C:, D:, F: etc.
Esta variable guarda el nombre del

Dir1 directorio número uno el cual es el
principal.
Esta variable guarda el nombre del

Dir2 directorio número dos el cual está dentro
del principal y sobre el cual se
introducirá el archivo.
Es el atributo de la clase que nos guarda

Ruta1 la ruta total que no es más que el destino
+ dir1 + dir2.
Archivo1 Es un objeto de tipo File para crear los

directorios.
CLASE ARCHIVO
import java.io.*;
class Archivo
{
String ruta2;
/***********************************************************************/
public void crea2(String rut)throws IOException
{
String nombre;
int sw=0;
while(sw==0)
{
nombre=JOptionPane.showInputDialog(null,
"Ingrese el nombre del archivo con su extension",
"Entrada",
File archivo2= new File(""+rut+"\\"+nombre+"");
if(archivo2.exists())
{
"El archivo ya existe, pruebe otro nombre",
"Salida",
}
else
{
"El archivo fue creado",
"Salida",
sw=1;
this.ruta2=archivo2.getAbsolutePath();
}
}
}
/***********************************************************************/
public void datos(String rut)
{
File archivo2= new File(""+rut+"");
System.out.println("\n*************** Datos del Archivo **********************");
System.out.println("\nNombre del archivo ==> "+archivo2.getName());
System.out.println("\nCamino ==============> "+archivo2.getPath());
System.out.println("\nCamino absoluto =====> "+archivo2.getAbsolutePath());
System.out.println("\nSe puede escribir ===> "+archivo2.canRead());
System.out.println("\nSe puede leer =======> "+archivo2.canWrite());
System.out.println("\nTamaño ==============> "+archivo2.length());
System.out.println("\n********************************************************
");
}
/***********************************************************************/
public void muestra(String rut)throws IOException
{
FileReader arch1 = new FileReader(""+rut+"");
BufferedReader in = new BufferedReader(arch1);
String s =new String();
System.out.println("\n**** Contenido del Archivo ****");
while((s=in.readLine())!= null)
System.out.println("\nRegistro:"+s);
System.out.println("\n******************************");
in.close();
}
/***********************************************************************/
public void Guarda_ruta(String rut)
{
this.ruta2=rut;
}
/***********************************************************************/
public String devuelve_ruta()
{
return(ruta2);
}
}
/***********************************************************************/
Descripción:
La clase archivo posee todo lo relacionado con la creación del archivo html, los datos del
mismo y la impresión del archivo en cualquier momento determinado.
Al igual que la clase subdirectorio posee un atributo llamado ruta2 en la cual se guarda la
ruta total, es decir, la de los dos directorios más el nombre del archivo creado.
Esta clase posee 5 métodos:
El método crea2: El cual crea el archivo donde se pide un nombre al usuario. Nótese que
recibe un argumento de la clase main, este argumento es la ruta de los directorios creados en
la clase subdirectorio para que el archivo al crearse quede dentro de los dos directorios.
El método datos: El cual imprime los datos del archivo en cualquier momento
determinado. Este método recibe un argumento y es la ruta total tanto de los dos directorios
como la del archivo. Esta ruta se logra al invocar el método devuelve_ruta de esta misma
clase en la clase main y se manda por argumento al método datos.
El método muestra: Este imprime el archivo en sí en cualquier momento determinado.
Obtiene la ruta de la misma manera que el método datos. Se invoca desde el main con el
objeto asociado a la clase archivo el método devuelve_ruta, en el main se lo asignamos a
una variable y esta la pasamos por argumento al método muestra para que imprima el
archivo.
El método Guarda_ruta: Este método es algo confuso pues recibe la ruta del archivo que
se crea en la clase esquema que posteriormente se explicara y la guarda en el atributo ruta2.
Este método nos sirve para no perder la ruta del archivo que se encuentre activo en un
momento determinado. Más adelante se explicara con más detalles.
El método devuelve_ruta: Este método devuelve la ruta del archivo al main para ser
utilizado a la hora de crear el esqueleto del archivo html y la creación del archivo
modificado, también a la hora de imprimir el archivo y mostrar sus datos.
VARIABLES IMPORTANTES UTILIZADAS EN LA CLASE ARCHIVO

Esta variable controla un ciclo while que

nos sirve para controlar o verificar que
Sw el usuario cree bien o no el archivo.
Si lo crea bien salimos del ciclo
cambiándole el valor, si no seguimos en
el mismo procedimiento hasta que el
usuario de una entrada válida.
Nombre Esta variable nos guarda el nombre del

archivo introducido por el usuario.
S Esta variable guarda la línea leída del

archivo para imprimirla en pantalla.
Es el atributo de la clase Archivo que nos

Ruta2 guarda la ruta de los dos directorios + el
nombre del archivo.
Archivo2 Es un objeto de tipo File para poder

crear el archivo.
CLASE ESQUEMA
import java.io.*;
class Esquema
{
/***********************************************************************/
public void crea3(String rut)throws IOException
{
String entrada;
File outputFile = new File(""+rut+"");
FileWriter out = new FileWriter(outputFile);
PrintWriter dato=new PrintWriter(out);
entrada="<html>";
dato.println(entrada);
entrada="<head>";
entrada="<title> </title>";
entrada="</head>";
entrada="<body>";
entrada="<h1> </h1>";
entrada="<p id=ss > </p>";
entrada="<li> </li>";
entrada="</body>";
entrada="</html>";
out.close();
}
/***********************************************************************/
public String modifica(String rut1,String rut2)throws IOException
{
int num,i;
String nombre,cadena;
FileReader arch1 = new FileReader(""+rut2+"");
BufferedReader in = new BufferedReader(arch1);
nombre=JOptionPane.showInputDialog(null,
"Ingrese el nuevo nombre del archivo con su extension",
"Entrada",
File outputFile = new File(""+rut1+"\\"+nombre+"");
FileWriter out = new FileWriter(outputFile);
PrintWriter dato=new PrintWriter(out);
String s =new String();
s=in.readLine();
dato.println(s);
s=in.readLine();
dato.println(s);
in.readLine();
cadena=JOptionPane.showInputDialog(null,
"Ingrese el titulo de la pagina",
"Entrada",
s="<title> "+cadena+" </title>";
dato.println(s);
s=in.readLine();
dato.println(s);
s=in.readLine();
dato.println(s);
"Ingrese el titulo principal",
"Entrada",
s="<h1> "+cadena+" </h1>";
dato.println(s);
in.readLine();
"Ingrese el parrafo",
"Entrada",
s="<p id=ss > "+cadena+" </p>";
dato.println(s);
in.readLine();
"Cuantos aspectos desea incluir en la lista del archivo html",
"Entrada",
num=Integer.parseInt(cadena);
for(i=0;i<num;i=i+1)
{
"Ingrese el aspecto "+(i+1)+" de la lista",
"Entrada",
s="<li> "+cadena+" </li>";
dato.println(s);
}
s="</body>";
dato.println(s);
s="</html>";
dato.println(s);
in.close();
out.close();
File arch2 = new File(""+rut2+"");
if (arch2.delete())
{
"El archivo anterior ha sido borrado satisfactoriamente",
"Salida",
}
else
{
"El archivo anterior no puede ser borrado",
"Salida",
}
File archivo= new File(""+rut1+"\\"+nombre+"");
cadena=archivo.getAbsolutePath();
return(cadena);
}
}
/***********************************************************************/
Descripción:
Esta clase es la encargada de abrir el archivo y escribir sobre él el esqueleto del archivo
html o también la modificación del mismo tanto en el título, el párrafo, los aspectos de la
lista, etc.
Esta clase posee dos métodos:
El método crea3: El cual recibe la ruta del archivo y escribe sobre él el esqueleto o base del
archivo html.
El método modifica: Este método recibe la ruta del archivo, abre el archivo en forma de
lectura y lee aquellas líneas que se plasmaran de forma igual en el segundo archivo y
aquellas que deben ser modificadas no las lee pero pide al usuario que introduzca los datos
necesarios, además elimina el archivo que contiene solo el esqueleto y devuelve la ruta del
nuevo archivo al main para ser pasada por argumento al método Guarda_ruta de la clase
archivo la cual no había sido totalmente visualizada.
VARIABLES IMPORTANTES UTILIZADAS EN LA CLASE

ESQUEMA
Esta variable guarda las líneas

Cadena necesarias para un archivo html para
luego ser utilizada para imprimirla en el
archivo primero.
Objeto creado con la intensión de

Dato utilizarlo para imprimir en el archivo
nuevo.
Variable que guarda la cantidad de

Num lineas que el usuario quiere imprimir en
la linea del codigo html  <li> </li>.
Variable que controla el ciclo donde se

I imprimen las lineas <li> </li>
respectivamente.
Arch2 Es un objeto de tipo File para poder

eliminar el archivo viejo.
Variable que guarda el nuevo nombre

Nombre del archivo el cual tendrá el titulo,
párrafo, etc. modificado.
Compilación del programa

En este paso se muestra una consola que le indica al usuario lo que puede
hacer
de aquí en adelante se da la creación de los archivos dentro de un

subdirectorio que a su ves esta dentro del directorio principal sin dejar a
un lado la localidad en que el usuario desee guardar todo su creación.
Muestra el destino en que va a guardar los directorios.
pregunta el nombre del directorio principal.
pregunta el nombre del subdirectorio.

muestra que el directorio fue creado
muestra la ruta en donde se creara el archivo.
menú que indica que se puede hacer
.
pregunta que nombre desea que tenga su archivo con su respectiva extensión
indica que el archivo fue creado.
indica la ruta completa.
Indica los datos del archivo creado.

Indica los datos y el esqueleto o estructura del archivo que se creo

pregunta que nombre le pondrá al nuevo archivo o al archivo modificado
pregunta que indique el titulo de la pagina
pregunta que indique el titulo principal de la pagina
pregunta que introduzca el párrafo que desea introducir

pregunta que introduzca cuantos aspectos desea introducir
pregunta que introduzca el primer aspectos a introducir
.
pregunta que introduzca el segundo aspectos a introducir
indica el archivo anterior a sido borrado.

muestra los datos del nuevo archivo
muestra el documento HTML que fue creado en la WEB
indica que ha salido del programa

CONCLUSION
Fernando
Básicamente este es nuestro código, nos costo bastante diseñarlo y usted está de testigo.
Aprendimos bastante sobre los archivos y los métodos para manejarlos y entendimos que el
lenguaje java es muy amplio y sobre todo mucho más práctico que el lenguaje C ya que las
clases y los métodos ya están diseñados solo hace falta investigarlos y aplicarlos a la hora
que se necesiten.
Norberto
Este trabajo es de gran importancia para mi ya que me ha permitido acceder a la Internet de

manera sencilla lo mas interesante fue conocer como es el esqueleto de una pagina WEB y
como modificarla y mas bien la creación de una pagina WEB a partir de un gran programa y
principalmente la creación de esta pagina en archivos lo que conllevo a una hazaña para
nosotros poder hacerlo.

Proyecto#1 Manejo de Archivos

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Proyecto#1 Manejo de Archivos

Hochgeladen von

Copyright:

Verfügbare Formate

REPUBLICA DE PANAMA

CENTRO REGIONAL UNIVERSITARIO

PROFESROR: DIEGO SANTIMATEO

AÑO LECTIVO: 2008

En el siguiente laboratorio veremos la funcionabilidad del lenguaje java respecto a la

La aplicación debe verificar si el archivo se está creando en un subdirectorio y si el nombre

CLASE DEL MAIN

Al elegir el usuario la opción 1 se invoca automáticamente el método crea de la clase

Al elegir el usuario la opción 2 se invoca automáticamente el método que nos devuelve la

Al elegir el usuario la opción 3 se invoca al método devuelve_ruta de la clase Archivo que

Y la opción 6 que es para salir del programa.

Esta variable nos guarda la opción que

Variables que guardan las rutas

La cadena nos guarda datos de tipo

La clase subdirectorio es la encargada de crear los directorios, el principal y el secundario el

Esta clase posee dos métodos:

Esta variable controla un ciclo while que

Destino Esta variable nos guarda el destino de

Esta variable guarda el nombre del

Esta variable guarda el nombre del

Es el atributo de la clase que nos guarda

Archivo1 Es un objeto de tipo File para crear los

Esta clase posee 5 métodos:

VARIABLES IMPORTANTES UTILIZADAS EN LA CLASE ARCHIVO

Esta variable controla un ciclo while que

Nombre Esta variable nos guarda el nombre del

S Esta variable guarda la línea leída del

Es el atributo de la clase Archivo que nos

Archivo2 Es un objeto de tipo File para poder

Esta clase posee dos métodos:

VARIABLES IMPORTANTES UTILIZADAS EN LA CLASE

Esta variable guarda las líneas

Objeto creado con la intensión de

Variable que guarda la cantidad de

Variable que controla el ciclo donde se

Arch2 Es un objeto de tipo File para poder

Variable que guarda el nuevo nombre

Compilación del programa

de aquí en adelante se da la creación de los archivos dentro de un

Muestra el destino en que va a guardar los directorios.

pregunta el nombre del directorio principal.

pregunta el nombre del subdirectorio.

muestra la ruta en donde se creara el archivo.

menú que indica que se puede hacer

indica la ruta completa.

menú que indica que se puede hacer

Indica los datos del archivo creado.

Indica los datos y el esqueleto o estructura del archivo que se creo

pregunta que indique el titulo de la pagina

pregunta que indique el titulo principal de la pagina

pregunta que introduzca el párrafo que desea introducir

pregunta que introduzca el primer aspectos a introducir

indica el archivo anterior a sido borrado.

menú que indica que se puede hacer

menú que indica que se puede hacer

indica que ha salido del programa

Este trabajo es de gran importancia para mi ya que me ha permitido acceder a la Internet de

Das könnte Ihnen auch gefallen