Embed Size (px)
Citation preview
UNIVERSIDAD DE PANAMÁ
CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS
FACULTAD DE INFORMÁTICA, ELECTRÓNICA Y COMUNICACIÓN
LICENCIATURA EN INFORMÁTICA PARA LA GESTIÓN EDUCATIVA Y
EMPRESARIAL
PROGRAMACIÓN IV
INF-212
LABORATORIO SEMANA # 7
DIRECTORIOS, SUBDIRECTORIOS Y ARCHIVOS
INTEGRANTES
JAIRO CONCEPCIÓN 9-724-1589
DIOMEDES MONTES 9-723-640
PROFESOR
DIEGO SANTIMATEO
FECHA
14 DE OCTUBRE DE 2008
Diagrama UML de Clases
El diagrama de Modelamiento de las clases para una mejor visualización de sus Atributos de la Clase y métodos.
Class Captura
String ruta; String carpeta; String msg1; String msg2; String dirArchivo; String newdir;
String msgCarpeta() String msgArchivo() String Capturadir1() String CapturaRut() String CapturaDir() Boolean VerificaExist()
Class CreaHtml
String NombreArchivo; String archivo; BufferedReader in ; PrintWriter ar; String dir; String dir2; String Nuevo;
String CreaciónHtml() Void InicializaHtml() BufferedReader AbrirArchivo() PrintWriter EscribeArchivo() void DeleteArchivo() void NuevoArchivo() void DespliegaArchivo()
Class CrearEtiquetas
void title() void Parrafo() void Lista() void Añadir() void Crearh1h2()
Class ManejoArch
String ruta; String carpeta; String subcar; String nuevaruta;
void CreaCarpeta()String CreaSubcarpeta()
Class ModifcarEtiquetas
void ModifParrafo()void ModifLista()void AñadirHr()void Crearh1h2()
Class Archivos
Main()
Descripción de los Atributos de la Clase y Métodos de cada una de las clases:
Class Archivos: Atributos de la Clase
String carp; guarda solamente el directorio creadoString rut; guarda solamente rutaString carp1; guarda la concatenación de la ruta y el directorio creadoString msg; guarda los mensajes de los métodos msgCarpeta() y msgArchivo()int opc, op1; guarda las opciones para los menúsBufferedReader in; PrintWriter ar;String nueva;String NombreArchivo;
/*********************************************************************************************/ /* Directorios, subdirectorios y archivos */ /* Algoritmo creardo por Jairo Concepcion y Diomedes montes */ /* 2008 */ /*********************************************************************************************/
/**************************************************************************************************************//*La clase Archivo se encarga de manejar el control de la creacion de Directorios, subdirectorios y archivos *//**************************************************************************************************************/
import java.io.*;import javax.swing.*;import java.lang.*;import java.text.*;class Archivos
{
public static void main (String[] args) throws IOException
{
String carp;String rut;String carp1;String msg;int opc,op1;BufferedReader in;PrintWriter ar;String nueva;String NombreArchivo;
Captura objeto = new Captura();
ManejoArch objeto1 = new ManejoArch();
CreaHtml objeto2 = new CreaHtml();
CrearEtiquetas objeto3 = new CrearEtiquetas();
ModifcarEtiquetas objeto4 = new ModifcarEtiquetas();
do{
String der = JOptionPane.showInputDialog(null," Menu Principal\n \n 1. Crear carpetas \n 2. Crear Subcarpeta \n 3. Crear Archivo Html \n 4. Crear y Modificar etiquetas del archivos \n 5. Salir");
op1= Integer.parseInt(der);
switch (op1) {
case 1: {rut=objeto.CapturaRut();
do{
carp=objeto.CapturaDir();carp1 = rut+"\\"+carp;objeto.msgCarpeta();
}while(objeto.VerificaExist(carp1));
objeto1.CreaCarpeta(rut,carp); }
break;
case 2: {rut=objeto.CapturaRut();objeto1.CreaSubcarpeta(rut);
}break;
case 3:{rut = objeto.CapturaRut();NombreArchivo = objeto.CapturaArchivo();
carp1 = objeto2.CreacionHtml(rut,NombreArchivo);
objeto.msgArchivo(); objeto.VerificaArchivo(carp1);
objeto2.InicializaHtml(); }
break;
case 4: {String dir=objeto.Capturadir1();NombreArchivo = objeto.CapturaArchivo();
String res; do{
res = JOptionPane.showInputDialog(null,"Submenu Que desea modifica \n \n 1. Titulo \n 2. Parrafo \n 3. Lista \n 4. Añadir hr \n 5. Crear h1 h2 \n 6. modificar parrafo \n 7. Modificar Lista \n 8. Modificar h1 ó h2 \n 9. voler al menu pricipal");
opc= Integer.parseInt(res);
in = objeto2.AbrirArchivo(dir,NombreArchivo); //Abrir el archivo
ar = objeto2.EscribeArchivo(dir); //Escribir en el archivo
switch (opc) {
case 1: {objeto3.title(in,ar);
//Añadir titulo al archivo }
break; case 2: {
objeto3.Parrafo(in,ar); //Añadir Parrafo al archivo }
break; case 3: {
objeto3.Lista(in,ar); //Añadir Lista al archivo
} break; case 4: {
objeto3.AñadirHr(in,ar); //Añadir hr al archivo }
break; case 5: {
objeto3.Crearh1h2(in,ar); //Añadir tamaño de letra al texto del archivo
} break; case 6: {
objeto4.ModifParrafo(in,ar);//Modificar Parrafo al archivo
} break; case 7: {
objeto4.ModifLista(in,ar); //Modifica Lista al archivo
} break; case 8:{
objeto4.Modificah1h2(in,ar); //Modifica el tamaño de letra del texto }
break;
case 9: { System.out.println("La
modificacion del archivo a terminado"); }
break;
}
objeto2.DeleteArchivo(dir,NombreArchivo); //Elimina el archivo viejo
objeto2.NuevoArchivo(dir,NombreArchivo); //Renombra el archivo nuevo
objeto2.DespliegaArchivo(dir,NombreArchivo); //muestra por consola el archivo modificado
}while(opc!=9); //ciclo de la opcion 2 "Modifica archivo"
}break;
case 5: { System.out.println("fin del
programa");}
break;
}
}while(op1!=5);//fin del menu Principal
}
}
Class Captura:
Atributos de la ClaseString ruta; guarda la ruta donde se desea crear el directorioString carpeta; guarda el nombre de la carpeta String msg1; guarda mensaje para luego verificar la creación de la carpetaString msg2; guarda mensaje para luego verificar la creación del archivoString dirArchivo; String newdir; guarda la dirección del archivo que desea modificarString archivo;
MétodosString msgCarpeta () : Este método devuelve una cadena con mensaje indicando que el nombre de la carpeta ya existe, será utilizada por el método VerificaExist(carp1,msg):, el cual desplegara al verificar su existencia. Se encierra para que introduzca un nombre valido.
String msgArchivo () : Al igual que el anterior devuelve una cadena con en mensaje, será utilizada por el método VerificaExist(carp1,msg): para verificar la creación del archivo.
String Capturadir1 () : Captura y devuelve la dirección completa del archivo que desea modificar String CapturaRut () : Captura y devuelve la ruta donde se va a crear el directorio.
String CapturaDir () : Captura y devuelve el nombre de la carpeta principal.
Boolean VerificaExist ( String carp1, String msg ) : Verifica la existencia en el “directorio” ya sea de la carpeta o el archivo que se desea crear. Para tal caso despliega el valor correspondiente de la variable “msg” que contiene un mensaje encapsulado. Además devuelve True si el archivo se ha creado en el directorio, al igual True para el caso que la carpeta ya exista. False para los casos contrarios.
/*Clase captura se encarga de controla el flujo de los mensajes, que permitira la captura de datos desde el teclado, como el nombre de la carpeta, subcarpeta, el nombre y ruta del archivo que se desea crear. Tambien tiene como funcion verificar si el archivo creado existe*/
import javax.swing.*;import java.io.*;class Captura
{
private String ruta;private String carpeta;private String msg1;private String msg2;private String dirArchivo;private String newdir;private String archivo;
/*********************************************************************************************/ /* Constructor de la clase Captura */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public Captura() { }
/*********************************************************************************************/ /* Metodo msgCarpeta genera un mensaje cuando el fichero existe */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void msgCarpeta()
{
this.msg1 = " La carpeta "+carpeta+" ya existe, Introduzca otro nombre";
}//fin del metodo msgCarpeta
/*********************************************************************************************/ /* Metodo msgArchivo genera un mensaje cuando el archivo se ha creado */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */ public void msgArchivo()
{
this.msg2 = "El archivo ha si creado en el subdirectorio";
}//fin frl metodo msgArchivo
/*********************************************************************************************/ /* Metodo Capturadir1 genera un mensaje indicando la ruta del archivo que se desea modificar */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public String Capturadir1()
{
this.newdir = JOptionPane.showInputDialog(null,"Introduzca la direccion del archivo que desea modificar");
return(newdir);
}//fin del metodo Capturadir1
/*********************************************************************************************/ /* Metodo CapturaArchivo genera un mensaje que captura el nombre del archivo */ /*********************************************************************************************/ /* ***** */
/* *** */ /* * */
public String CapturaArchivo()
{
this.archivo = JOptionPane.showInputDialog(null, "Indique nombre de archivo:");
return(archivo);
}//fin del metodo CapturaArchivo
/*********************************************************************************************/ /* Metodo CapturaRut genera un mensaje que captura la ruta donde se desea crear la carpeta */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public String CapturaRut()
{
this.ruta = JOptionPane.showInputDialog(null,"Introduzca la ruta deseada");
return(ruta);
}//fin del metodo CapturaRut
/*********************************************************************************************/ /* Metodo CapturaDir genera un mensaje que capturando el nombre de la carpeta */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public String CapturaDir()
{
this.carpeta = JOptionPane.showInputDialog(null,"Introduzca el nombre de la carpeta");
return(carpeta);
}//fin del metodo CapturaDir
/*********************************************************************************************/ /* Metodo VerificaExist verifica si la carpeta existe en la direccion deseada */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public boolean VerificaExist(String carp1)
{
File dir = new File(carp1);
if(dir.exists()) {
JOptionPane.showMessageDialog(null,""+msg1);
return(true); } else{
return(false);
} }//fin del metodo VerificaExist
/*********************************************************************************************/ /* Metodo VerificaArchivo verifica si el archivo existe en la direccion deseada */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void VerificaArchivo(String carp1)
{ File dir = new File(carp1);
if(dir.exists()) {
JOptionPane.showMessageDialog(null,""+msg2); } }//fin del metodo VerificaArchivo
}/*********************************************************************************************/ /*********************** Fin de la clase Captura *********************/ /*********************************************************************************************/
Class ManejoArch:Atributos de la Clase
String ruta ; recibe del constructor la “ruta” donde se desea crear el directorioString carpeta ; recibe del constructor el nombre de la carpeta principal del directorio a crearString subcar; guarda el nombre de la subcarpeta a crear.String nuevaruta; guarda la concatenación de la ruta, carpeta y subcarpeta, esta será la nueva dirección.
Métodos
void CreaCarpeta (): Este método se encarga de “crear” la carpeta principal dentro de la ruta antes dada.
String CreaSubcarpeta (): Este método crea la “subcarpeta”, primeramente comprueba que la concatenacion de la ruta y la carpeta principal existan y que sean un directorio, luego comprueba sise puede crear o no.
import javax.swing.*;import java.io.*;
class ManejoArch
{
private String ruta;private String carpeta;private String subcar;private String nuevaruta;
/*********************************************************************************************/ /* Constructor */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public ManejoArch() //Bob {
}
/*********************************************************************************************/ /* Metodo lista se encarga de añadir una lista con las etiquetas <li> y sus respectivos id */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void CreaCarpeta(String rut,String carp)
{
File dir = new File(rut+"\\"+carp);
dir.mkdir();
}//fin del metodo Crea Carpeta
/*********************************************************************************************/ /* Metodo CreaSubcarpeta se encarga de crear una subcarpeta */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void CreaSubcarpeta(String rut)
{
this.subcar = JOptionPane.showInputDialog(null,"Introduzca el nombre de la subcarpeta que desea crear");
this.nuevaruta = rut+"\\"+subcar;
File dir = new File(rut);
if(dir.isDirectory())
{
File dir2 = new File(nuevaruta);
if(dir2.mkdirs())
{
JOptionPane.showMessageDialog(null," La subcarpeta "+subcar+" ha sido creada ");
}
else
{
JOptionPane.showMessageDialog(null," La subcarpeta "+subcar+" no se ha podido ser creada");
}
}
else
{
JOptionPane.showMessageDialog(null,"No se puede crear la subcarpeta, la ruta no contiene ningun directorio");
}
// return(this.nuevaruta);
}//fin del metodo Crea Subcarpeta
}/*********************************************************************************************/ /*********************** Fin de la clase ManejoArch *********************/ /*********************************************************************************************/
Class CreaHtmlAtributos de la Clase
String NombreArchivo;String archivo;BufferedReader in ;PrintWriter ar;String dir;String dir2;String Nuevo;
Métodos:String CreaciónHtml ( String dirección ) : Este método Se encarga de “crear” un Archivo HTML vacío y devuelve la dirección exacta donde se encuentra. Este archivo será inicializado en otra clase.
Void InicializaHtml () : Este método toma el archivo creado y le introduce el esqueleto con las etiquetas HTML.
BufferedReader AbrirArchivo (String dire,String NombreArchivo) Este método realiza la función de abrir el archivo que se desea modificar, retorna el objeto para permitir que el archivo pueda ser accesado por otras clases y así realizar la modificación de las etiquetas deseadas en el archivo.
PrintWriter Escribe archivo (String dire) Este método se encarga de crear un nuevo archivo html que almacenara los datos iniciales y modificaciones del archivo principal, este archivo funciona como auxiliar ya que será renombrado posteriormente devuelve el objeto para permitir que el archivo sea utilizado para luego devolver todos los datos al archivo inicial.
La aplicación de los dos últimos métodos se debe a que no encontramos un método que nos permitiera leer y escribir datos en un mismo archivo.
void DeleteArchivo(String dire,String NombreArchivo) Este método elimina el archivo html inicial ya que al pasarle los datos al nuevo archivo había quedado vació y no tiene utilidad ni importancia su existencia para el programa y menos para el usuario.
void NuevoArchivo(String dire, String NombreArchivo): Este método renombra al nuevo archivo creado y le asigna el nombre del archivo principal, con este paso el usuario no tendrá distracciones con el nombre del archivo ya que sigue siendo el mismo nombre que el inicialmente ingreso.
void DespliegaArchivo(String dire,String NombreArchivo) este método despliega por consola el código del archivo html con el numero de línea, para que el usuario tenga la posibilidad apreciar los cambios y seleccionar donde desea hacer modificaciones o ingresar nuevos elementos.
/*********************************************************************************************/ /*La clase CreaHtml se encargara de crear un archivo de tipo html, como tambien el de */ /*inicializar dicho archivo con el codigo html, tambien abre, escribe en modo de escritura */ /*y elimiina y renombra el archivo */ /*********************************************************************************************/
import javax.swing.*;import java.io.*;
class CreaHtml {
private String NombreArchivo;private String archivo;private BufferedReader in;private PrintWriter ar;private String dir;private String dir2;private String nuevo;
/*********************************************************************************************/ /* Constructor */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public CreaHtml() {}
/*********************************************************************************************/ /* Metodo CreacionHtml crea un archivo en la ruta deseada */ /*********************************************************************************************/
/* ***** */ /* *** */ /* * */ public String CreacionHtml(String direccion, String NombreArchivo)
{this.dir=direccion;
try {
File file = new File (direccion+"/"+NombreArchivo+".html");
file.createNewFile(); }catch
(Exception e)
{
System.err.println("*Error al abrir el archivo...\n" +e);
}this.archivo =
direccion+"/"+NombreArchivo+".html";return(archivo);
}//fin del metodo creacion Html
/*********************************************************************************************/ /* Metodo InicializaHtml crea el esqueleto html en el archivo */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */ public void InicializaHtml() throws IOException
{
try {
String arde = archivo;
FileWriter archivo = new FileWriter(arde);
PrintWriter ar = new PrintWriter(archivo);
ar.println("<html>");
ar.println("<head>");
ar.println("<title></title>");
ar.println("</head>");
ar.println("<body>");
ar.println("</body>");
ar.println("</html>");
ar.close();
} catch (Exception e)
{
e.printStackTrace();
} }//fin del metodo InicializaHtml
/*********************************************************************************************/ /* Metodo AbrirArchivo se encarga de abrir el archivo que se desea modificar */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public BufferedReader AbrirArchivo(String dire,String NombreArchivo) throws IOException
{ File inputFile = new
File(dire+"\\"+NombreArchivo); //archivo de entrada FileReader arch1 = new
FileReader(inputFile); in = new BufferedReader(arch1); return(in); }//fin del metodo Abrir Archivo
/*********************************************************************************************/ /* Metodo EscribeArchivo se encarga de escribir en el archivo que se desea modificar */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */ public PrintWriter EscribeArchivo(String dire) throws IOException
{ FileWriter archivo = new
FileWriter(dire+"\\"+"datos1.html"); PrintWriter ar = new
PrintWriter(archivo); return(ar); }//fin del metodo EscribeArchivo
/*********************************************************************************************/ /* Metodo DeleteArchivo se encarga de borrar en el archivo viejo */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void DeleteArchivo(String dire,String NombreArchivo) throws IOException { File arch = new File(dire+"\\"+NombreArchivo);
arch.delete(); }//fin del metodo Delete Archivo
/*********************************************************************************************/ /* Metodo NuevoArchivo se encarga de renombrar el archivo */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */ public void NuevoArchivo(String dire,String NombreArchivo) throws IOException
{ File arch1 = new
File(dire+"\\"+NombreArchivo); File arch2 = new
File(dire+"\\"+"datos1.html"); arch2.renameTo(arch1);
}//fin del metodo Nuevo Archivo
/*********************************************************************************************/ /* Metodo DespliegaArchivo se encarga de desplegar los datos de archivo html */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */ public void DespliegaArchivo(String dire,String NombreArchivo) throws IOException {
try{FileReader arch1 = new
FileReader(dire+"\\"+NombreArchivo);BufferedReader in = new
BufferedReader(arch1);String s = new String();int l=0;
while((s = in.readLine())!=null)
{ l++;
System.out.println(l+" "+s); }
in.close();
}catch(Exception e) {
System.err.println("Error al leer o al abrir el archivo \n"+e); }
}//fin del metodo Despliega Archivo
}/*********************************************************************************************/ /*********************** Fin de la clase Crea Html *********************/ /*********************************************************************************************/
Class CrearEtiquetas
Métodos:void title(BufferedReader in, PrintWriter ar): Este método se encarga de introducirle el las etiquetas de titulo al archivo html.
void Párrafo(BufferedReader in, PrintWriter ar): Este método permite añadir párrafos al archivo, el programa inmediatamente crea sus respectivas etiquetas (p) html. Antes de crearlo primero el usuario deberá especificar el ID, que será identificador para cuando desee hacer moficicaciones.
void Lista(BufferedReader in, PrintWriter ar): El método permite listar la cantidad de texto que el usuario desee, la aplicación asigna al código html del archivo, las etiquetas Li correspondientes, el usuario tiene la opción de escoger el numero de línea donde desea colocar las listas. Para cada lista el usuario dede indicar su ID correspondiente.
void AñadirHr(BufferedReader in, PrintWriter ar): Este método permite al usuario introducir la etiqueta hr en el archivo html, en la línea que el usuario desee.
void Crearh1h2() Este método permite añadir según el usuario las etiquetas h1 y h2 a los párrafos del archivo, se requiere que ingrese el Id cada vez que crea esta etiqueta
import java.io.*;import javax.swing.*;import java.lang.*;import java.text.*;
class CrearEtiquetas
{
public CrearEtiquetas() {
}
/*********************************************************************************************/ /* Metodo title se encarga de añadir el titulo con sus respectivas etiquetas */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void title(BufferedReader in, PrintWriter ar) throws IOException
{
String s=""; String titulo = JOptionPane.showInputDialog(null,"Introduzca el titulo");
try{
while((s = in.readLine())!= null) { if(s.indexOf("<title>")!=-1)
{
s = "<title>"+titulo+"</title>"; } ar.println(s);
}
ar.close(); in.close();
} catch (Exception e) { e.printStackTrace(); }
}
/*********************************************************************************************/ /* Metodo Parrafo se encarga de añadir el parrafo con sus respectivas etiquetas, id */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void Parrafo(BufferedReader in, PrintWriter ar) throws IOException
{
String s=""; int sw=0; String id = JOptionPane.showInputDialog(null,"Introduzca el id del parrafo"); String parrafo = JOptionPane.showInputDialog(null,"Introduzca el parrafo");
try{
while((s = in.readLine())!= null) { if(s.indexOf("<body>")!=-1)
{
ar.println(s);
ar.println (s = "<p id ="+id+">"+parrafo+"</p>"); sw=1;
}
if(sw==0){
ar.println(s); }
sw=0; } ar.close(); in.close();
} catch (Exception e) { e.printStackTrace(); }
}
/*********************************************************************************************/ /* Metodo lista se encarga de añadir una lista con las etiquetas <li> y sus respectivos id */ /*********************************************************************************************/ /* ***** */
/* *** */ /* * */
public void Lista(BufferedReader in, PrintWriter ar) throws IOException
{ int l=0; String idlista; String texto; int sw=0; String s=""; String numlista =
JOptionPane.showInputDialog(null,"Introduzca la cantidad de Lista que desea introducir");
int num = Integer.parseInt(numlista);
String linea = JOptionPane.showInputDialog(null,"Introduzca el numero de la linea donde desea colocar las listas");
int line = Integer.parseInt(linea);
try{
while((s = in.readLine())!= null) { l++; if(l ==line)
{
for(int i=0;i<num;i++){
idlista = JOptionPane.showInputDialog(null,"Introduzca el id de la lista ");
texto = JOptionPane.showInputDialog(null,"Introduzca el texto de la lista");
ar.println ("<li id ="+idlista+">"+texto+"</li>");
} }
ar.println(s);
}
ar.close(); in.close();
}catch (Exception e){
e.printStackTrace(); }
}//fin del metodo Lista
/*********************************************************************************************/ /* Metodo AñadirHr se encarga de añadir la etiqueta hr en el archivo */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void AñadirHr(BufferedReader in, PrintWriter ar) throws IOException
{String s = new String();
int l=0;String linea =
JOptionPane.showInputDialog("Introduzca el numero de la linea donde desea colocar el hr ");int num = Integer.parseInt(linea);
try{
while((s = in.readLine())!=null) {
l++;if(l == num){
ar.println("<hr>");
} ar.println(s);
} ar.close(); in.close();
} catch (Exception e)
{
e.printStackTrace(); }
}//fin del metodo AñadirHr
/*********************************************************************************************/ /* Metodo Crearh1h2 se encarga de añadir un h1 ó h2 a un parrafo */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void Crearh1h2(BufferedReader in, PrintWriter ar) throws IOException
{int l=0;String s=new String();String id =
JOptionPane.showInputDialog("Introduzca el id del parrafo o lista al que le desea añadir h1 ó h2");
String tipoh = JOptionPane.showInputDialog("Que tipo desea utilizar \n 1.h1 \n 2. h2");
int tipo = Integer.parseInt(tipoh);
try{
while((s = in.readLine())!=null) {
l++;
if(s.indexOf(id)!=-1){if(tipo
== 1){
s = "<h1>"+s+"</h1>";
}else
if(tipo ==2){
s = "<h2>"+s+"</h2>";
}else
System.out.println("Este rango de etiqueta no es valido");
} ar.println(s);
} in.close(); ar.close();
. } catch (Exception e)
{
e.printStackTrace(); }
}//fin del metodo Crearh1h2
}/*********************************************************************************************/ /*********************** Fin de la clase Crea etiquetas *********************/ /*********************************************************************************************/
Class ModifcarEtiquetasAtributos de la Clase de la Clase
Métodos:void ModifParrafo(BufferedReader in, PrintWriter ar) Este método permite modificar el párrafo que el usuario desee del archivo, para tal caso debe introducir el Id correspondiente, luego el contenido del nuevo parrafo. El párrafo a modificar será reemplazado por el nuevo párrafo.
void ModifLista(BufferedReader in, PrintWriter ar): Este método le permite al usuario modificar la lista que desee a través del Id, la nueva lista introducida reempezara a la anterior.
String DivideLinea(String s, String et1, String et2) Este método se encarga de extraer de una línea que contiene las etiquetas h1 o h2, la línea limpia sin estas etiquetas (las elimina) Este método es privado y será utilizado por el método Modificah1h2() que ingresara la modificación que desee el usuario.
void Modificah1h2(BufferedReader in, PrintWriter ar) Metodo Modificah1h2 permite modificar los h1 o h2 de una lista o párrafo por medio del id. Utiliza un método privado llamado DivideLinea que nos dará una linea sin etiquetas
import java.io.*;import javax.swing.*;import java.lang.*;import java.text.*;import java.util.StringTokenizer;
class ModifcarEtiquetas
{
/*********************************************************************************************/ /* Constructor */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public ModifcarEtiquetas() { }
/*********************************************************************************************/ /* Metodo MOdifParrafo permite modificar el parrafo por medio del id */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void ModifParrafo(BufferedReader in, PrintWriter ar) throws IOException
{
String s=""; int sw=0; String id = JOptionPane.showInputDialog(null,"Introduzca el id del parrafo"); String parrafo = JOptionPane.showInputDialog(null,"Introduzca el parrafo");
try{
while((s = in.readLine())!= null) { if(s.indexOf(id)!=-1)
{ s = "<p
id ="+id+">"+parrafo+"</p>"; } ar.println(s);
} ar.close(); in.close();
} catch (Exception e) { e.printStackTrace(); }
}//fin del metodo Modif Parrafo
/*********************************************************************************************/ /* Metodo ModifLista permite modificar una lista por medio del id */ /*********************************************************************************************/ /* ***** */ /* *** */
/* * */
public void ModifLista(BufferedReader in, PrintWriter ar) throws IOException
{ String s="";
String id = JOptionPane.showInputDialog(null,"Introduzca el id de la lista"); String text = JOptionPane.showInputDialog(null,"Introduzca el texto");
try{
while((s = in.readLine())!= null) { if(s.indexOf(id)!=-1)
{ s =
"<li id ="+id+">"+text+"</li>"; } ar.println(s);
} ar.close(); in.close();
} catch (Exception e){
e.printStackTrace(); }
}//fin del metodo Modif Lista
/*********************************************************************************************/ /*Metodo DivideLinea divide la linea donde encuentra un h1 ó h2 y devuelve la linea sin */ /*etiquetas que luego sera utilizada en el metodo Modificah1h2 de esta misma clase,tiene */ /*como parametros la linea con etiquetas y el tipo de etiqueta que debe contener esa linea. */ /*las cuales nos permitiran delimitar */ /*********************************************************************************************/ /* ***** */ /* Metodo privado *** */ /* * */
private String DivideLinea(String s, String et1,String et2) {
String[] result = s.split(et1); String[] result2 = result[1].split(et2); String sn = result2[0]; return(sn);
}
/*********************************************************************************************/ /*Metodo Modificah1h2 permite modificar los h1 o h2 de una lista o parrafo por medio del id */ /* Utiliza un metodo privado llamado DivideLinea que nos dara una linea sin etiquetas */ /*********************************************************************************************/ /* ***** */ /* *** */ /* * */
public void Modificah1h2(BufferedReader in, PrintWriter ar) throws IOException
{String s="";String sn="";String et1,et2;int l=0;String id =
JOptionPane.showInputDialog("Introduzca el id del parrafo o lista al que le desea añadir h1 ó h2");
String tipoh = JOptionPane.showInputDialog("Que tipo desea utilizar \n 1.h1 \n 2. h2");
int tipo = Integer.parseInt(tipoh);
try{
while((s = in.readLine())!=null) {
l++; if(s.indexOf(id)!=-1){
if(tipo == 1){
et1="<h2>";et2="</h2>";
sn=DivideLinea(s,et1,et2);
s = "<h1>"+sn+"</h1>";
}else if(tipo ==2){
et1="<h1>";et2="</h1>";
sn=DivideLinea(s,et1,et2);
s = "<h2>"+sn+"</h2>";
}else System.out.println("Este rango de etiqueta no es valido");
} ar.println(s);
} ar.close(); in.close();
} catch (Exception e)
{
e.printStackTrace();
} }//fin del metodo Modificah1h2
}
/*********************************************************************************************/ /*********************** Fin de la clase Modifica etiquetas *****************/ /*********************************************************************************************/
EJECUCIÓN DE LA APLICACION
falta la ruta de la subcarpeta
ver en la pagina
