Ok. Creo que ya lo tengo.
La clase Persona no la he cambiado
Las clases Jugadores, Personal y Proveedores, el único cambio que he hecho ha sido añadirles a cada uno su propio metodo .toString(), ya que como explique antes, es muy útil y ayuda mucho a reducir código.
Jugadores:
@Override
public String toString()
{
return matricula + "|" + super.getNombre() + "|" + super.getAp() + "|"
+ super.getAm() + "|" + numeroca + "|" + posicion + "|" + estatus +
"|" + super.getSexo() + "|";
}
Personal:
@Override
public String toString()
{
return clave + "|" + super.getNombre() + "|" + super.getAp() + "|"
+ super.getAm() + "|" + puesto + "|" + especialidad + "|" + tiempoe
+ "|" + super.getSexo() + "|";
}
Proveedores:
@Override
public String toString()
{
return super.getNombre() + "|" + direccion + "|" + ciudad + "|"
+ email + "|" + telefono + "|";
}
Fíjate que para obtener los atributos de la clase padre Persona, hay que usar la palabra super seguido del métod get() que necesitamos.
Sobre la clase LeerMostrar5
No he hecho cambios importantes. Tan solo eliminar lineas de código innecesarias, como por ejemplo los try catch cuando estamos pidiendo datos de tipo String.
También he quitado las declaraciones de atributos donde estaban puestos unos objetos de Personal, Jugadores y Proveedores.
Tampoco son necesarios para esta clase.
LeerMostrar5:
import javax.swing.JOptionPane;
public final class LeerMostrar5 {
public LeerMostrar5()
{}
public int getMatricula2()
{
int matricula = 0;
boolean bandera = false;
do
{
try
{
matricula = (Integer.parseInt(JOptionPane.showInputDialog("Matricula del jugador:")));
bandera=true;
}
catch(NumberFormatException e)
{JOptionPane.showMessageDialog(null,"El dato ingresado no es correcto");}
}while(bandera!=true);
JOptionPane.showMessageDialog(null,"Matricula\n"+matricula);
return matricula;
}
public String getNombreJ()
{
String nombre = JOptionPane.showInputDialog("Nombre:\r\n");
JOptionPane.showMessageDialog(null,"Nombre\n"+nombre);
return nombre;
}
public String getApe()
{
String apeP = JOptionPane.showInputDialog("Apellido paterno:");
JOptionPane.showMessageDialog(null,"Apellido Paterno\n"+apeP);
return apeP;
}
public String getAma()
{
String apeM = JOptionPane.showInputDialog("Apellido materno:");
JOptionPane.showMessageDialog(null,"Apellido Materno\n"+apeM);
return apeM;
}
public int getNumC()
{
boolean bandera=false;
int numCam=0;
do
{
try
{
numCam = (Integer.parseInt(JOptionPane.showInputDialog("Numero de camisa:\r\n"+"")));
bandera=true;
}
catch(Exception e)
{JOptionPane.showMessageDialog(null,"El dato ingresado no es correcto");}
}while(bandera!=true);
JOptionPane.showMessageDialog(null,"Numero de Camisa\n"+numCam);
return numCam;
}
public String getPosic()
{
String posicion = JOptionPane.showInputDialog("Posicion:\r\n");
JOptionPane.showMessageDialog(null,"Posicion\n"+posicion);
return posicion;
}
public String getEstatus1()
{
String status = JOptionPane.showInputDialog("Estatus:");
JOptionPane.showMessageDialog(null,"Estatus\n"+status);
return status;
}
public Object getSex1()
{
Object sexo = JOptionPane.showInputDialog(null,"Seleccione sexo","Sexo",
JOptionPane.QUESTION_MESSAGE,null, new Object[]
{ "Masculino", "Femenino"},"Masculino");
JOptionPane.showMessageDialog(null,"Sexo\n"+sexo);
return sexo;
}
/*Ingresar datos de personal*/
public int getClave()
{
boolean bandera = false;
int clave = 0;
do
{
try
{
clave = (Integer.parseInt(JOptionPane.showInputDialog("Clave:\t")));
bandera=true;
}
catch(NumberFormatException e)
{JOptionPane.showMessageDialog(null,"El dato ingresado no es correcto");}
}while(bandera!=true);
return clave;
}
public String getNombrep()
{
String nombre = JOptionPane.showInputDialog("Nombre:\t");
JOptionPane.showMessageDialog(null,"Nombre\n"+nombre);
return nombre;
}
public String getAp2()
{
String apeP = JOptionPane.showInputDialog("Apellido Paterno:\t");
JOptionPane.showMessageDialog(null,"Apellido Paterno\n"+apeP);
return apeP;
}
public String getAm2()
{
String apeM = JOptionPane.showInputDialog("Apellido materno:");
JOptionPane.showMessageDialog(null,"Apellido Materno\n"+apeM);
return apeM;
}
public String getPuesto1()
{
String puesto = JOptionPane.showInputDialog("Puesto:");
JOptionPane.showMessageDialog(null,"Puesto\n"+puesto);
return puesto;
}
public String getEsp()
{
String espe = JOptionPane.showInputDialog("Especialidad:");
JOptionPane.showMessageDialog(null,"Especialidad\n"+espe);
return espe;
}
public int getTiempoe()
{
boolean bandera = false;
int tiempo = 0;
do
{
try
{
tiempo = (Integer.parseInt(JOptionPane.showInputDialog("Tiempo en la empresa:\t")));
bandera=true;
}
catch(NumberFormatException nft)
{JOptionPane.showMessageDialog(null,"Error ingreso un dato no valido");}
}while(bandera!=true);
JOptionPane.showMessageDialog(null, "Tiempo en la empresa\n" + tiempo);
return tiempo;
}
public Object getSex2()
{
Object sexo = (JOptionPane.showInputDialog(null,"Seleccione sexo","Sexo",
JOptionPane.QUESTION_MESSAGE,null, new Object[]
{ "Masculino", "Femenino"},"Masculino"));
JOptionPane.showMessageDialog(null, "Sexo\n" + sexo);
return sexo;
}
/* Ingresar Proveedores*/
public String getNombrePr()
{
String provee = JOptionPane.showInputDialog("Proveedor:\t");
JOptionPane.showMessageDialog(null, "Proveedor\n" + provee);
return provee;
}
public String getDirecpr()
{
String direc = JOptionPane.showInputDialog("Direccion:\t");
JOptionPane.showMessageDialog(null, "Direccion\n" + direc);
return direc;
}
public String getCiudad1()
{
String ciudad = JOptionPane.showInputDialog("Ciudad:\t");
JOptionPane.showMessageDialog(null, "Ciudad\n" + ciudad);
return ciudad;
}
public String getEmail()
{
String mail = JOptionPane.showInputDialog("E-Mail:\t");
JOptionPane.showMessageDialog(null, "E-Mail\n" + mail);
return mail;
}
public int getTelefono()
{
boolean bandera = false;
int telef = 0;
do
{
try
{
telef = (Integer.parseInt(JOptionPane.showInputDialog("telefono:\t")));
bandera=true;
}
catch(NumberFormatException nft)
{JOptionPane.showMessageDialog(null,"Error ingreso un dato no valido");}
}while(bandera!=true);
JOptionPane.showMessageDialog(null, "Telefono\n" + telef);
return telef;
}
}
Se podría haber reducido más el código, ya que por ejemplo hay métodos que son iguales.
Los métodos para pedir nombres o los de pedir apellidos.. son iguales tanto si es para una Jugador como si es para Personal.
Así que con solo un método para pedir Nombre nos hubiera servido para todas las clases.
De hecho, esta clase no tiene porque saber nada acerca de Jugadores, Proveedores,...
Su única función es mostrar ventanas con los mensajes adecuados para pedir los datos correspondientes.
La clase MenuBueno no he cambiado nada. Lo único que considero que es un poco innecesaria su existencia. El metodo main() podría estar incluido en la clase MenuV2 y lanzarse el programa desde ahí. Pero bueno, no importa demasiado.
Sobre la clase MenuV2, tampoco ha cambiado demasiado.
He quitado de nuevo varios atributos innecesarios y objetos innecesarios.
Esta clase no necesita ningún BufferedReader, ni objetos Jugadores, ni tampoco objetos MenuV2 (es decir, ella misma estaba declarada como un atributo más)
MenuV2:
import java.io.IOException;
import javax.swing.JOptionPane;
public final class MenuV2 {
private CrearFile2 cf2 = new CrearFile2();
public MenuV2()
{}
public void setMenuV2() throws IOException
{
int opcion = 0;
do
{
opcion=Integer.parseInt(JOptionPane.showInputDialog(null,"1.Registrar\n"+"2.Eliminar registro\n"+"3.Consultar\n"+"4.Salir"));
switch (opcion)
{
case 1:
int opc=0;
do
{
opc=Integer.parseInt(JOptionPane.showInputDialog(null,"1.Agregar jugadores\n"+"2.Agregar Personal\n"+"3.Agregar Proveedores\n"+"4.Salir"));
switch(opc){
case 1:
cf2.setCrearJugadores(); break;
case 2:
cf2.setCrearPersonal(); break;
case 3:
cf2.setCrearProveedores(); break;
case 4:
JOptionPane.showMessageDialog(null,"Volviendo al menu principal");break;
default:
JOptionPane.showMessageDialog(null,"Opcion invalida");
}
}while(opc!=4);
break;
case 2:
cf2.setEliminar(); break;
case 3:
cf2.setConsulta();break;
case 4:
JOptionPane.showMessageDialog(null,"Salio del sistema"); break;
default:
JOptionPane.showMessageDialog(null,"Opcion invalida");
}
}while(opcion!=4);
}
}
Esta clase solo necesita tener como atributo a la clase CrearFile2, ya que todo lo que tiene que hacer es mostrar menus de opciones, y segun lo que escoja el usuario, pedirle a CrearFile2 que haga una cosa o la otra.
Y ahora llegamos a la clase CrearFile2, que es la más importante de todas.
Aquí es donde más cambios he hecho, aunque a nivel funcional ya estaba casi completa.
De nuevo he eliminado atributos y objetos que no eran necesarios.
He simplificado los métodos para crear Jugadores, Personal y Proveedores al valernos del metodo toString()
Además en estos metodos ya no pregunto si el archivo existe o no existe. En realidad nos da igual si existe o no. Si te fijas, tu preguntabas pero hacías exactamente lo mismo tanto si existía como si no..
Para estos metodos no necesitamos saber si existe o no. El objeto BufferedWriter se encarga por si solo.
Si el archivo existe agregará nuevas lineas, si no existe, creará un archivo nuevo.
Los metodos setConsulta() y setMostrarB() son dos versiones distintas para hacer una misma cosa.
He modificado el setConsulta() para hacerlo funcionar con un objeto BufferedReader y es el que estoy usando para hacer consultas.
El setMostrarB() no lo estoy usando pero lo he dejado como version alternativa ya que es lo mismo pero con un Scanner en lugar de un BufferedReader.
Por último, el metodo setEliminar(), que es el más dificil y el que te traía de cabeza supongo.
Lo he simplificado utilizando un ArrayList para leer las lineas del archivo antes de eliminar lo que pida el usuario.
Tu lo intentabas hacer con un arreglo normal, pero esta estructura es demasiado primitiva y hay que complicar mucho el código para que funcione bien.
En este método he puesto bastante comentarios explicando cada paso y creo que se entiende bastante bien. Miratelo y pregunta cualquier duda que tengas.
No se si te pondrán alguna pega por estar usando un ArrayList, si hubiera que utilizar un arreglo simple, dímelo y podemos hacer una versión alternativa.
CrearFile2:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
import javax.swing.JOptionPane;
public final class CrearFile2 {
/*
* Como atributos de clase solo necesitamos el objeto File para escribir al archivo
* y un objeto LeerMostrar5 para pedir datos usando sus métodos.
*/
File archivo= new File("C:\\Prueba\\EquipoV.txt");
LeerMostrar5 lm5 = new LeerMostrar5();
public void setCrearJugadores()
{
try
{
//Preparamos archivo para escribir
BufferedWriter bw = new BufferedWriter(new FileWriter(archivo, true));
//Creamos un jugador nuevo.
Jugadores jugador = new Jugadores();
//Pedimos datos usando métodos de la clase LeerMostrar5
jugador.setMatricula(lm5.getMatricula2());
jugador.setNombre(lm5.getNombreJ());
jugador.setAp(lm5.getApe());
jugador.setAm(lm5.getAma());
jugador.setNumeroCa(lm5.getNumC());
jugador.setPosicion(lm5.getPosic());
jugador.setEstatus(lm5.getEstatus1());
jugador.setSexo(lm5.getSex1());
/*
* Ya tenemos un Jugador creado.
* Ahora guardamos todos sus datos en el archivo.
* Usamos el metodo .toString() para tener todos los datos
* preparados en una sola linea.
*/
bw.write(jugador.toString());
bw.newLine();
bw.close();
}
catch(Exception ex) {
ex.printStackTrace();
JOptionPane.showMessageDialog(null,ex.getLocalizedMessage());
}
}
public void setCrearPersonal(){
try {
BufferedWriter bw = new BufferedWriter(new FileWriter(archivo, true));
Personal personal = new Personal();
personal.setClave(lm5.getClave());
personal.setNombre(lm5.getNombrep());
personal.setAp(lm5.getAp2());
personal.setAm(lm5.getAm2());
personal.setPuesto(lm5.getPuesto1());
personal.setEspecialidad(lm5.getEsp());
personal.setTiempoE(lm5.getTiempoe());
personal.setSexo(lm5.getSex2());
bw.write(personal.toString());
bw.newLine();
bw.close();
}
catch(Exception ex) {
ex.printStackTrace();
JOptionPane.showMessageDialog(null,ex.getLocalizedMessage());
}
}
public void setCrearProveedores() throws IOException
{
try
{
BufferedWriter bw = new BufferedWriter(new FileWriter(archivo, true));
Proveedores proveedor = new Proveedores();
proveedor.setNombre(lm5.getNombrep());
proveedor.setDireccion(lm5.getDirecpr());
proveedor.setCiudad(lm5.getCiudad1());
proveedor.setEmail(lm5.getEmail());
proveedor.setTelefono(lm5.getTelefono());
bw.write(proveedor.toString());
bw.newLine();
bw.close();
}
catch(Exception ex) {
ex.printStackTrace();
JOptionPane.showMessageDialog(null,ex.getLocalizedMessage());
}
}
public void setConsulta()
{
if (archivo.exists())
{
String datoAbuscar = JOptionPane.showInputDialog("Dato a buscar:");
try {
BufferedReader br = new BufferedReader(new FileReader(archivo));
String lineaArchivo = br.readLine();//Leemos primera linea
while (lineaArchivo != null) {//Si no es null, es que hemos podido leer linea
if (lineaArchivo.startsWith(datoAbuscar))
JOptionPane.showMessageDialog(null,"Dato Buscado:\n" + lineaArchivo);
lineaArchivo = br.readLine();//Leemos otra linea, si no quedasen, tendriamos null y el bucle terminará
}
br.close();
} catch(Exception e) {
e.printStackTrace();
JOptionPane.showMessageDialog(null, e.getLocalizedMessage());
}
}
else
JOptionPane.showMessageDialog(null, "No se puede consultar\nNo existe fichero: " + archivo.getAbsolutePath());
}
public void setMostrarB() throws IOException
{
try {
Scanner lector = new Scanner(archivo);
String datoAbuscar = JOptionPane.showInputDialog("Dato a buscar:");
while (lector.hasNextLine()) {
String datoBuscado = lector.nextLine();
if (datoBuscado.startsWith(datoAbuscar)) {
JOptionPane.showMessageDialog(null,"Dato buscado\n" + datoBuscado);
}
}
}catch (FileNotFoundException e) {
JOptionPane.showMessageDialog(null, "No se ha encontrado el fichero " + archivo.getAbsolutePath());
e.printStackTrace();//Muestra por consola la "traza" del error
}
}
public void setEliminar() {
if (archivo.exists())
{
String clave = JOptionPane.showInputDialog("Dame clave a eliminar");
/*
* Leeremos todas las lineas existentes en el archivo para tenerlas en memoria.
* Como no sabemos cuantas lineas puede haber, es más comodo guardarlas en un ArrayList
* ya que no hay que indicarle un tamaño específico, y permite añadir/eliminar datos.
* Un arreglo normal no nos da esta flexibilidad y nos complica demasiado el codigo.
*
* Cada vez que leemos una nueva linea, podemos comprobar si coinciden con la clave
* que queremos eliminar. Si coincide, preguntamos al usuario si es esta la clave que quiere
* eliminar.
* Si DENIEGA eliminar la clave, la añadimos al ArrayList y seguimos leyendo lineas.
* Si CONFIRMA que es la clave a eliminar, NO la añadiremos al ArrayList, aunque seguiremos
* leyendo y preguntando en caso de encontrar más coincidencias.
*/
try {
ArrayList<String> lineas = new ArrayList<>();
BufferedReader br = new BufferedReader(new FileReader(archivo));
String linea = br.readLine();
while (linea != null)
{
if (linea.startsWith(clave))//Coincidencia, preguntamos si quiere eliminar
{
int confirmar = JOptionPane.showConfirmDialog(null, "Se ha encontrado:\n"
+ linea + "\n¿SEguro que quiere borrar?", "Confirmar Eliminacion", JOptionPane.YES_NO_OPTION);
if (confirmar == JOptionPane.YES_OPTION)//SI quiere borrar. Por tanto, no la añadimos al ArrayList
{
JOptionPane.showMessageDialog(null, "El dato será eliminado");
}
else//No quiere borrar. Por tanto, SI lo añadimos al ArrayList
{
lineas.add(linea);
}
}
else//No ha habido coincidencia. Añadimos linea al ArrayList sin preguntar nada.
{
lineas.add(linea);
}
linea = br.readLine();//Leemos nueva linea y repetimos bucle
}
br.close();
/*
* Bucle de lectura finalizado.
* Ahora mismo en el ArrayList tenemos las lineas que
* el usuario NO ha querido borrar. Solo queda volver a
* escribirlas en el fichero sustituyendo todos los datos que contiene ahora.
*
* Por tanto, primero intentaremos borrar el archivo actual para crear uno nuevo
*/
if (archivo.delete())
{
BufferedWriter bw = new BufferedWriter(new FileWriter(archivo, true));
//Ahora recorremos el ArrayList y vamos grabando cada una de las lineas que contiene
for (String line: lineas)
{
bw.write(line);
bw.newLine();
}
//Listo. Ya se ha han guardado los cambios.
bw.close();
JOptionPane.showMessageDialog(null, "Los cambios se han guardado");
}
else//Por algun motivo, no se ha podido borrar el archivo
{
JOptionPane.showMessageDialog(null, "No se ha podido modificar el archivo: " + archivo.getAbsolutePath());
}
}
catch (Exception e) {
e.printStackTrace();
JOptionPane.showMessageDialog(null, e.getLocalizedMessage());
}
}
}
}
Y esto es todo. Yo lo he probado y funciona.
Creo que dijiste que una opcion era mostrar TODO el contenido del archivo de texto al usuario.
Es lo único que faltaría por añadir.
Cualquier duda, ya sabes, pregunta por aquí
Tema: programa java registrar eliminar consultar modificar FileWriter BufferedW jGRASP (Leído 13441 veces)
RSS -
WAP2