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 Archivos

Main()

Class Captura Class ManejoArch Class CrearEtiquetas Class

String ruta;
String carpeta;
String msg1;
String msg2;
String dirArchivo;
String newdir;
void CreaCarpeta()
String CreaSubcarpeta()
String msgCarpeta()
String msgArchivo()
String Capturadir1()
String CapturaRut()
String CapturaDir()
Boolean VerificaExist()
ModifcarEtiquetas
Class CreaHtml
String ruta;
String carpeta; String NombreArchivo;
String subcar; String archivo;
String nuevaruta; BufferedReader in ;
PrintWriter ar;
String dir;
String dir2;
void title()
String Nuevo;
void Parrafo() void ModifParrafo()
void Lista() void ModifLista()
void Añadir() void AñadirHr()
void Crearh1h2() void Crearh1h2()
String CreaciónHtml()
Void InicializaHtml()
BufferedReader AbrirArchivo()
PrintWriter EscribeArchivo()
void DeleteArchivo()
void NuevoArchivo()
void DespliegaArchivo()
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 creado
String rut; guarda solamente ruta
String carp1; guarda la concatenación de la ruta y el directorio creado
String msg; guarda los mensajes de los métodos msgCarpeta() y msgArchivo()
int opc, op1; guarda las opciones para los menús
BufferedReader 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 Clase
String ruta; guarda la ruta donde se desea crear el directorio
 String carpeta; guarda el nombre de la carpeta
String msg1; guarda mensaje para luego verificar la creación de la carpeta
String msg2; guarda mensaje para luego verificar la creación del archivo
String dirArchivo;
String newdir; guarda la dirección del archivo que desea modificar
String archivo;

Métodos
String 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 directorio
String carpeta; recibe del constructor el nombre de la carpeta principal del directorio a crear
String 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 CreaHtml
Atributos 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 ModifcarEtiquetas
Atributos 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