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-1562NORBERTO 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:ruta1=objeto1.devuelve_ruta();objeto2.crea2(ruta1);ruta2=objeto2.devuelve_ruta();objeto3.crea3(ruta2);JOptionPane.showMessageDialog(null,"La ruta del archivo es ==> "+ruta2+"","Salida",

JOptionPane.INFORMATION_MESSAGE);break;case 3:ruta2=objeto2.devuelve_ruta();objeto2.datos(ruta2);break;case 4:ruta2=objeto2.devuelve_ruta();objeto2.muestra(ruta2);break;case 5:ruta1=objeto1.devuelve_ruta();ruta2=objeto2.devuelve_ruta();ruta3=objeto3.modifica(ruta1,ruta2);objeto2.Guarda_ruta(ruta3);break;case 6:JOptionPane.showMessageDialog(null,"Ha salido del programa !!!!","Salida",JOptionPane.INFORMATION_MESSAGE);break;default:JOptionPane.showMessageDialog(null,"Eliga una opcion valida del menu","Salida",JOptionPane.ERROR_MESSAGE);break;}}}catch(Exception e){JOptionPane.showMessageDialog(null,"Error en la captuta de los datos","Salida",JOptionPane.ERROR_MESSAGE);}}}

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

opcion

Esta variable nos guarda la opción que el usuario elige del menú del programa y

se usa un switch para elegir entre las distintas posibilidades a la hora de

invocar a las clases con sus métodos.

Ruta1,ruta2,ruta3

Variables que guardan las rutas retornadas de los métodos devuelve_ruta

de las clases Subdirectorio, Archivo y Esquema.

cadena

La cadena nos guarda datos de tipo String como la opción que elige el

usuario del menú que luego se transforma a entero para asignárselo a

opción.

CLASE SUBDIRECTORIO

import java.io.*;import javax.swing.JOptionPane;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",JOptionPane.QUESTION_MESSAGE);dir2=JOptionPane.showInputDialog(null,"Ingrese el nombre del subdirectorio","Entrada",JOptionPane.QUESTION_MESSAGE);File archivo1=new File(""+destino+"\\"+dir1+"\\"+dir2+"");if(archivo1.mkdirs()){JOptionPane.showMessageDialog(null,"El directorio fue creado","Salida",JOptionPane.INFORMATION_MESSAGE);sw=1;this.ruta1=archivo1.getAbsolutePath();}else{if(archivo1.canWrite()){JOptionPane.showMessageDialog(null,"El directorio ya existe, pruebe otro nombre","Salida",JOptionPane.ERROR_MESSAGE);

}else{JOptionPane.showMessageDialog(null,"El destino del directorio no es valido, pruebe otro !!!","Salida",JOptionPane.ERROR_MESSAGE);}}}}/***********************************************************************/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


Sw

Esta variable controla un ciclo while que nos sirve para controlar o verificar que 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.

Dir1Esta variable guarda el nombre del directorio número uno el cual es el

principal.

Dir2Esta variable guarda el nombre del directorio número dos el cual está

dentro del principal y sobre el cual se introducirá el archivo.

Ruta1Es el atributo de la clase que nos guarda 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.*;import javax.swing.JOptionPane;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",JOptionPane.QUESTION_MESSAGE);File archivo2= new File(""+rut+"\\"+nombre+"");if(archivo2.exists()){JOptionPane.showMessageDialog(null,"El archivo ya existe, pruebe otro nombre","Salida",JOptionPane.ERROR_MESSAGE);}else{JOptionPane.showMessageDialog(null,"El archivo fue creado","Salida",JOptionPane.INFORMATION_MESSAGE);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


Sw

Esta variable controla un ciclo while que nos sirve para controlar o verificar que

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.

Ruta2Es el atributo de la clase Archivo que

nos 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.*;import javax.swing.JOptionPane;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>";dato.println(entrada);entrada="<title> </title>";dato.println(entrada);entrada="</head>";dato.println(entrada);entrada="<body>";dato.println(entrada);entrada="<h1> </h1>";dato.println(entrada);entrada="<p id=ss > </p>";dato.println(entrada);entrada="<li> </li>";dato.println(entrada);entrada="</body>";dato.println(entrada);entrada="</html>";dato.println(entrada);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",JOptionPane.QUESTION_MESSAGE);

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",JOptionPane.QUESTION_MESSAGE);s="<title> "+cadena+" </title>";dato.println(s);s=in.readLine();dato.println(s);s=in.readLine();dato.println(s);cadena=JOptionPane.showInputDialog(null,"Ingrese el titulo principal","Entrada",JOptionPane.QUESTION_MESSAGE);s="<h1> "+cadena+" </h1>";dato.println(s);in.readLine();cadena=JOptionPane.showInputDialog(null,"Ingrese el parrafo","Entrada",JOptionPane.QUESTION_MESSAGE);s="<p id=ss > "+cadena+" </p>";dato.println(s);in.readLine();cadena=JOptionPane.showInputDialog(null,"Cuantos aspectos desea incluir en la lista del archivo html","Entrada",JOptionPane.QUESTION_MESSAGE);num=Integer.parseInt(cadena);for(i=0;i<num;i=i+1){cadena=JOptionPane.showInputDialog(null,"Ingrese el aspecto "+(i+1)+" de la lista","Entrada",JOptionPane.QUESTION_MESSAGE);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()){JOptionPane.showMessageDialog(null,"El archivo anterior ha sido borrado satisfactoriamente","Salida",JOptionPane.INFORMATION_MESSAGE);}else{JOptionPane.showMessageDialog(null,"El archivo anterior no puede ser borrado","Salida",JOptionPane.ERROR_MESSAGE);}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


CadenaEsta variable guarda las líneas

necesarias para un archivo html para luego ser utilizada para imprimirla en el

archivo primero.

DatoObjeto creado con la intensión de

utilizarlo para imprimir en el archivo nuevo.

NumVariable que guarda la cantidad de

lineas que el usuario quiere imprimir en la linea del codigo html <li> </li>.

IVariable que controla el ciclo donde se

imprimen las lineas <li> </li> respectivamente.

Arch2 Es un objeto de tipo File para poder eliminar el archivo viejo.

NombreVariable que guarda el nuevo 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.

Documents

Proyecto#1 Manejo de Archivos