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: 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
cadena
Variables que guardan las rutas retornadas de los métodos devuelve_ruta de las clases Subdirectorio, Archivo y Esquema. 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
VARIABLE
Sw
Destino
Dir1
Dir2
Ruta1
Archivo1
DESCRIPCION 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. Esta variable nos guarda el destino de los directorios ya sea C:, D:, F: etc. Esta variable guarda el nombre del directorio número uno el cual es el principal. Esta variable guarda el nombre del 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 la ruta total que no es más que el destino + dir1 + dir2. 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
VARIABLE
Sw
DESCRIPCION 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.
Ruta2
Archivo2
CLASE ESQUEMA
Es el atributo de la clase Archivo que nos guarda la ruta de los dos directorios + el nombre del archivo. Es un objeto de tipo File para poder crear el archivo.
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=""; dato.println(entrada); entrada=""; dato.println(entrada); entrada="
"; dato.println(entrada); entrada=""; dato.println(entrada); entrada=""; dato.println(entrada); entrada="
"; dato.println(entrada); entrada="
"; dato.println(entrada); entrada="
"; dato.println(entrada); entrada=""; dato.println(entrada); entrada=""; 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="
"+cadena+" "; 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="
"+cadena+"
"; dato.println(s); in.readLine(); cadena=JOptionPane.showInputDialog(null, "Ingrese el parrafo", "Entrada", JOptionPane.QUESTION_MESSAGE); s="
"+cadena+"
"; 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
"; dato.println(s); } s="