Proyecto peleadores competicion con altas, bajas y cambios, Java

[Mephisto]

El proyecto consiste en un torneo de box donde dare de alta a 8 peleadores los cuales debo ingresar su codigo de peleador, nombre, edad y apodo cada uno con sus respectivas excepciones, utilize un metodo consulta para verificar que el codigo de peleador no se repitiera.

El metodo participantes sirve para darme el listado de los participantes.
Puse el metodo revolver que sirve para hacer los enfrentamientos aleatoriamente por medio de random. Donde ocupo su ayuda seria en bajas donde quiero utilizar un bufferedreader para ingresar los resultados cada pelea (Por ejemplo: "Pedro vs Juan" Resultado "122 a 112" y asi de todas las peleas. Y de cada pelea eliminar al de menor puntaje.

Aprecio su ayuda, muchas gracias!

Código: [Seleccionar]

package torneo.helpers;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import torneo.exceptions.CodigoDeParticipanteExistenteException;
import torneo.exceptions.CodigoInvalidoException;
import torneo.exceptions.EdadNoPermitida;
import torneo.exceptions.ElNombreEstaVacioException;
import torneo.identity.Peleador;
import torneo.persist.BaseDatos;

public class PeleadorHelper<Public> {

public void  alta() throws CodigoInvalidoException,
CodigoDeParticipanteExistenteException, ElNombreEstaVacioException,
EdadNoPermitida {

int Codigo = 0;

PeleadorHelper pl = new PeleadorHelper();
BufferedReader teclado = new BufferedReader(new InputStreamReader(
System.in));

System.out.println("Ingresa el codigo del participante");

try {
Codigo = Integer.parseInt(teclado.readLine());
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (Codigo <= 0) {
throw new CodigoInvalidoException();
} else {
if (pl.consulta(Codigo) == true) {
throw new CodigoDeParticipanteExistenteException();
}
// --------------------------------------------------------------------------------------

String nom = null;
System.out.println("Ingresa tu nombre");

try {
nom = (teclado.readLine());

} catch (Exception e) {
// TODO: handle exception
}
if ((nom == null) || (nom.trim().equals(""))) {
throw new ElNombreEstaVacioException();
}

// ----------------------------------------------------------------------------------------
double edad = 0;
System.out.println("Edad");
try {
edad = Integer.parseInt(teclado.readLine());
} catch (Exception e) {
// TODO: handle exception
}
if ((edad < 0) || (edad < 18)) {
throw new EdadNoPermitida();

}

// ------------------------------------------------------------------------------------------
int punt =0;
int aleatorio;

aleatorio=(int)(Math.random()*(100-80+1)+80);



//-----------------------------------------------------------------------------------------

String apod = null;
System.out.println("Agrega tu apodo");

try {
apod = (teclado.readLine());

} catch (Exception e) {
// TODO: handle exception
}
if ((apod == null) || (nom.trim().equals(""))) {
throw new ElNombreEstaVacioException();
} else {

Peleador pe = new Peleador();

pe.setCodigopeleador(Codigo);
pe.setNombre(nom);
pe.setPuntuacion(punt);
pe.setApodo(apod);
pe.setEdad(edad);
BaseDatos.getPeleadores().add(pe);
System.out.println("Ingreso del peleador al INFIERNO");

             //----------------------------------------------------------------------------------------------


}
}

}

public void revolver() {
System.out.println(" Cartelera de peleas de eliminatoria: ");
String[] peleas = { BaseDatos.getPeleadores().get(0).getNombre(),
BaseDatos.getPeleadores().get(1).getNombre(),
/*/BaseDatos.getPeleadores().get(2).getNombre(),
BaseDatos.getPeleadores().get(3).getNombre(),
BaseDatos.getPeleadores().get(4).getNombre(),
BaseDatos.getPeleadores().get(5).getNombre(),
BaseDatos.getPeleadores().get(6).getNombre(),
BaseDatos.getPeleadores().get(7).getNombre(),
BaseDatos.getPeleadores().get(8).getNombre(),
BaseDatos.getPeleadores().get(9).getNombre()/*/
};
List<String> emparejados = new ArrayList<String>();
Random rand = new Random();
int randomNum = rand.nextInt(((peleas.length - 1) - 0) + 1);

int losPeleadores = 0;

while (losPeleadores < peleas.length) {
if (emparejados.size() == peleas.length - 1)
break;

String elejidos1 = "";
do {
randomNum = rand.nextInt(((peleas.length - 1) - 0) + 1);
elejidos1 = peleas[randomNum];
} while (emparejados.contains(peleas[randomNum]));

emparejados.add(elejidos1);

String elejidos2 = "";
do {
randomNum = rand.nextInt(((peleas.length - 1) - 0) + 1);
elejidos2 = peleas[randomNum];
} while (emparejados.contains(peleas[randomNum]));

emparejados.add(elejidos2);
System.out.println(elejidos1 + " vs " + elejidos2);
losPeleadores++;
}

for (String elpeleador : peleas)
        if (!emparejados.contains(elpeleador))
            System.out.println("- Exento: " + elpeleador);
}

public void baja(){
for (Peleador peleador:BaseDatos.getPeleadores()) {

System.out.println(Math.min(BaseDatos.getPeleadores().get(0).getPuntuacion(), BaseDatos.getPeleadores().get(1).getPuntuacion()));
if(BaseDatos.getPeleadores().get(0).getPuntuacion() > BaseDatos.getPeleadores().get(1).getPuntuacion()) {

}

}



}
public void Participantes() {

for (Peleador peleador : BaseDatos.getPeleadores()) {

System.out.println("Peleador: " + peleador.getApodo());
}
}

public boolean consulta(int codigo) {
for (Peleador peleador : BaseDatos.getPeleadores()) {
if (peleador.getCodigopeleador() == codigo) {
return true;
}
}
return false;
}


}


[Alex Rodríguez]

Hola, el código que has incluido no compila. Para poder compilarlo sería necesario que incluyas el código de todas las clases necesarias (si es muy largo puedes subirlo en un archivo comprimido como adjunto).

En el código que has incluido veo la siguiente línea:

BaseDatos.getPeleadores().add(pe);

Para interpretarla bien tendría que ver el código, pero para realizar bajas parece que lo lógico sería usar lo mismo: hacer una petición de datos de los resultados de la pelea, y a continuación mostrar un mensaje informando de que el peleador que pierde ha sido eliminado de los peleadores. Dicha eliminación ser haría con el método

BaseDatos.getPeleadores().remove(pe);

No sé si este método está definido o tendrías que definirlo (sin ver el código no puedo saberlo)

Saludos

[Mephisto]

Buen dia, Gracias por contestar
Este es mi proyecto

esta es la clase BaseDatos

Código: [Seleccionar]

package torneo.persist;
import java.util.ArrayList;

import torneo.identity.Peleador;

public class BaseDatos {

private static ArrayList<Peleador> Peleadores;

public static ArrayList<Peleador> getPeleadores() {
if (Peleadores==null){
Peleadores=new ArrayList<Peleador>();
}
return Peleadores;
}}es la clase Peleador

Código: [Seleccionar]

package torneo.identity;

public class Peleador {
private int codigopeleador;
String nombre;
double edad;
String apodo;
int puntuacion;
public int getCodigopeleador() {
return codigopeleador;
}
public void setCodigopeleador(int codigopeleador) {
this.codigopeleador = codigopeleador;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public double getEdad() {
return edad;
}
public void setEdad(double edad) {
this.edad = edad;
}
public String getApodo() {
return apodo;
}
public void setApodo(String apodo) {
this.apodo = apodo;
}
public int getPuntuacion() {
return puntuacion;
}
public void setPuntuacion(int puntuacion) {
this.puntuacion = puntuacion;
}

}lo tengo acomodado por las clases de "Excepciones"

Código: [Seleccionar]

package torneo.exceptions;

public class CodigoDeParticipanteExistenteException extends Exception {

}

Código: [Seleccionar]

package torneo.exceptions;

public class CodigoInvalidoException extends Exception {

}

Código: [Seleccionar]

package torneo.exceptions;

public class EdadNoPermitida extends Exception {

}

Código: [Seleccionar]

package torneo.exceptions;

public class ElNombreEstaVacioException extends Exception {

}Aqui la clase peleadorhelper, donde doy de alta a los peleadores y pongo sus respectivas excepciones y hago uso del metodo consulta donde checho que no se repita el codigo del peleador, utilize el metodo de revolver para que me sorteara a los peleadores lo que ocupo es que en la forma que me los sorteo les agregue su puntuacion y se eliminen a los perdedores y realmente no se como seria el codigo que tengo que hacer

Código: [Seleccionar]

package torneo.helpers;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import torneo.exceptions.CodigoDeParticipanteExistenteException;
import torneo.exceptions.CodigoInvalidoException;
import torneo.exceptions.EdadNoPermitida;
import torneo.exceptions.ElNombreEstaVacioException;
import torneo.identity.Peleador;
import torneo.persist.BaseDatos;

public class PeleadorHelper<Public> {

public void alta() throws CodigoInvalidoException,
CodigoDeParticipanteExistenteException, ElNombreEstaVacioException,
EdadNoPermitida {

int Codigo = 0;

PeleadorHelper pl = new PeleadorHelper();
BufferedReader teclado = new BufferedReader(new InputStreamReader(
System.in));

System.out.println("Ingresa el codigo del participante");

try {
Codigo = Integer.parseInt(teclado.readLine());
} catch (NumberFormatException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (Codigo <= 0) {
throw new CodigoInvalidoException();
} else {
if (pl.consulta(Codigo) == true) {
throw new CodigoDeParticipanteExistenteException();
}
// --------------------------------------------------------------------------------------

String nom = null;
System.out.println("Ingresa tu nombre");

try {
nom = (teclado.readLine());

} catch (Exception e) {
// TODO: handle exception
}
if ((nom == null) || (nom.trim().equals(""))) {
throw new ElNombreEstaVacioException();
}

// ----------------------------------------------------------------------------------------
double edad = 0;
System.out.println("Edad");
try {
edad = Integer.parseInt(teclado.readLine());
} catch (Exception e) {
// TODO: handle exception
}
if ((edad < 0) || (edad < 18)) {
throw new EdadNoPermitida();

}

// ------------------------------------------------------------------------------------------
int punt = 0;
int aleatorio;

aleatorio = (int) (Math.random() * (100 - 80 + 1) + 80);

// -----------------------------------------------------------------------------------------

String apod = null;
System.out.println("Agrega tu apodo");

try {
apod = (teclado.readLine());

} catch (Exception e) {
// TODO: handle exception
}
if ((apod == null) || (nom.trim().equals(""))) {
throw new ElNombreEstaVacioException();
} else {

Peleador pe = new Peleador();

pe.setCodigopeleador(Codigo);
pe.setNombre(nom);
pe.setPuntuacion(punt);
pe.setApodo(apod);
pe.setEdad(edad);
BaseDatos.getPeleadores().add(pe);
System.out.println("__________________________________");
System.out.println("|                                |");
System.out.println("|Ingreso del peleador al INFIERNO|");
System.out.println("|                                |");Apreciaria su ayuda, Gracias!

[Ogramar]

Hola Mephisto, la última clase que pegaste se cortó, pero la he podido recuperar del mensaje anterior donde sí estaba completa. Lo que no veo es la clase con el método main, ¿se cortó también?

[Mephisto]

Hola Ogramar,gracias por contestar.
Creo que si se corto aqui esta la clase main

Código: [Seleccionar]

package torneo.test;

import torneo.helpers.PeleadorHelper;
import torneo.exceptions.CodigoDeParticipanteExistenteException;
import torneo.exceptions.CodigoInvalidoException;
import torneo.exceptions.EdadNoPermitida;
import torneo.exceptions.ElNombreEstaVacioException;

public class ClaseMain {
public static void main(String[] args) {
PeleadorHelper fight = new PeleadorHelper();

try {

fight.alta();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
fight.alta();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
fight.alta();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
fight.alta();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
fight.alta();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
fight.alta();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
fight.alta();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
fight.alta();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");

fight.Participantes();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");
fight.revolver();
System.out
.println("¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨");

} catch (CodigoInvalidoException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (CodigoDeParticipanteExistenteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ElNombreEstaVacioException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (EdadNoPermitida e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

[Ogramar]

Aquí hay una cosa extraña:

int losPeleadores = 0;

while (losPeleadores < peleas.length) {


Dado que peleas.length siempre será mayor que 1, el while siempre será true. Por tanto lo anterior equivale a:

while (true) {

Es decir, un bucle que se repite infinitamente (a no ser que sea detenido mediante una instrucción break interna). Un while true es algo que no se suele considerar un buen diseño de programación.



Ahora mismo tienes comentadas varias líneas:

String[] peleas = { BaseDatos.getPeleadores().get(0).getNombre(),
            BaseDatos.getPeleadores().get(1).getNombre(),
            /*/BaseDatos.getPeleadores().get(2).getNombre(),

Esto da lugar a que nunca se pueda salir del bucle, y por tanto el bucle se queda bloqueado. ¿Por qué? Porque la condición de salida es if (emparejados.size() == peleas.length - 1)

Para poder llegar a la condición de salida parece que se necesita un número impar de peleadores de forma que se creen parejas de dos y quede uno libre. Pero esto no parece lógico ¿qué ocurre si el número de peleadores es par?




Otra cosa mal programada es por ejemplo la repetición de código que tienes en el método main: eso se debe hacer a través de un bucle. Repites 8 veces las instrucciones asociadas al alta de un peleador, pero eso deberías hacerlo con un bucle.


Otra cosa que no es coherente es esta:

      String[] peleas = { BaseDatos.getPeleadores().get(0).getNombre(),
            BaseDatos.getPeleadores().get(1).getNombre(),
            BaseDatos.getPeleadores().get(2).getNombre(),
            BaseDatos.getPeleadores().get(3).getNombre(),
            BaseDatos.getPeleadores().get(4).getNombre(),
            BaseDatos.getPeleadores().get(5).getNombre(),
            BaseDatos.getPeleadores().get(6).getNombre(),
            BaseDatos.getPeleadores().get(7).getNombre(),
            BaseDatos.getPeleadores().get( 8 ).getNombre(),
            BaseDatos.getPeleadores().get(9).getNombre()
            };

Aquí haces una introducción de datos manual basada en múltiples invocaciones... eso deberías hacerlo recorriendo la colección y añadiendo elementos al array, no con una introducción manual. Si no lo haces así no logras una automatización verdadera, es decir, un programa que trabaje con cualquier número de peleadores, sino solo un programa que trabaje con 10 peleadores o con un número prefijado.

Otra cosa poco coherente es que si nos equivocamos al introducir un código y en vez de un número introducimos una letra, el programa se interrumpa. Si llevamos por ejemplo introducidos los datos de 5 peleadores y nos equivocamos, perdemos todo el trabajo hecho.

En resumen, demasiadas cosas como para hacer una revisión de este código. Te recomiendo seguir este curso: http://aprenderaprogramar.com/index.php?option=com_content&view=category&id=68&Itemid=188

Donde se revisan todos los conceptos de la programación Java. Para que este código tuviera un buen diseño habría que revisarlo al completo, quizás fuera preferible empezar desde cero e ir paso a paso. Ahora, si no tienes tiempo quizás se trate solo de intentar terminarlo... depende de lo que quieras hacer.

Salu2