Cita:
Iniciado por GreenEyed 
Hola,
Puedes ver algo de teoría y código aquí: [url]http://www.javahispano.org/contenidos/es/como_ordenar_colecciones_de_objetos/[/url]
La idea es la siguiente. En Java tu puedes definir una Collection que sea ordenada (en tu caso lo más ajustado parece un TreeSet) y puedes definir tu el orden pasandole al TreeSet un objeto del tipo Comparator, que implemente un método compareTo() en el cual tu comparas un objeto con otro, de la clase que sabes que vas a meter en el TreeSet, según las reglas que te convenga. La ventaja es que en este caso sólo has de comparar dos objetos.
Después simplemente vas añadiendo objetos al TreeSet y cuando has acabado, puedes sacarlos ordenados sin más. Están ordenados "solitos".
Si buscas "java comparator" en Google encontraras más ejemplos, el javadoc etc.
S!
PD: El problema de "empate" no es cuestión de código, es cuestión de definir bien cual es el resultado que quieres obtener en cualquiera de las combinaciones posibles. Luego implementarlo es lo fácil.
Hola, lo primero siento resucitar este hilo pero no he encontrado nada que me sirva por internet.
Estoy creando una tabla de clasificación para un torneo de Baloncesto, y estoy utilizando los criterios de desempate de la ACB http://www.acb.com/redaccion.php?id=30992 .
Estoy utilizando el Comparator de java que comentaba GreenEyed, y todo bien, pero el problema viene que el Comparator compara dos objetos y no se como debo actuar para triples(o más) empates.
Aqui os dejo el código de mi Comparator:
Código:
package com.proyecto.util.listas;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
import com.proyecto.dominio.Torneo;
import com.proyecto.dominio.User;
import com.proyecto.dominio.UserTorneo;
import com.proyecto.dominio.PartidoIndividualVersus;
// Hay que tener en cuenta que ordena de menor a mayor por lo que para ordenarlo de mayor a menor tenemos que poner ut2 antes
// Está hecho, pero solo para 2 equipos, no se como se hace para más (de momento).
public class ACBUserTorneoComparator implements Comparator<UserTorneo>{
public int compare(UserTorneo ut1, UserTorneo ut2){
if(ut2.getPartidosGanados() - ut1.getPartidosGanados()!=0){ // Mayor nº de victorias
return ut2.getPartidosGanados() - ut1.getPartidosGanados();
}
else if(ut1.getPartidosJugados() - ut2.getPartidosJugados()!=0){ // Menor nº de partidos jugados
return ut1.getPartidosJugados() - ut2.getPartidosJugados();
}
else{
Torneo tor = ut1.getId().getParentTorneo();
User us1 = ut1.getId().getParentUser();
User us2 = ut2.getId().getParentUser();
int rondas = tor.getRondas();
int enfrentamientos = 0;
Set<PartidoIndividualVersus> partidoSet = tor.getPartidosIndVersus();
Set<PartidoIndividualVersus> partidoSetVS = new HashSet<PartidoIndividualVersus>(); // Util para cuando hayan enfrentado todo
Iterator<PartidoIndividualVersus> it = partidoSet.iterator();
while(it.hasNext()){
PartidoIndividualVersus pi = it.next();
if(pi.getConfirmado()){
if((pi.getParentLocal().equals(us1) && // Si se enfrentan los ut1 y ut2
pi.getParentVisitante().equals(us2)) ||
(pi.getParentLocal().equals(us2) &&
pi.getParentVisitante().equals(us1))){
enfrentamientos++;
partidoSetVS.add(pi);
}
}
}
if(enfrentamientos < rondas){ // Si no se han enfrentado todas las veces
return AverageFavorCocienteGlobal(ut1,ut2);
}
else{ // Si ya se han enfrentado todas las veces
int victoriasUT1 = 0;
int victoriasUT2 = 0;
int favorUT1 = 0; // En el average entre 2 no hace falta saber los ptos en contra
int favorUT2 = 0;
it = partidoSetVS.iterator();
while(it.hasNext()){
PartidoIndividualVersus pi = it.next();
if(pi.getParentGanador().equals(us1)){
victoriasUT1++;
}
else if(pi.getParentGanador().equals(us2)){ // No haria falta el if pero de momento lo dejamos asi
victoriasUT2++;
}
if(pi.getParentLocal().equals(us1)){
favorUT1 += pi.getPuntosLocal();
favorUT2 += pi.getPuntosVisitante();
}
else{
favorUT2 += pi.getPuntosLocal();
favorUT1 += pi.getPuntosVisitante();
}
}
if(victoriasUT2 - victoriasUT1 != 0){ // Enfrentamiento Directo
return victoriasUT2 - victoriasUT1;
}
else if(favorUT2 - favorUT1 != 0){ // Average Directo
return favorUT2 - favorUT1;
}
else{
return AverageFavorCocienteGlobal(ut1,ut2);
}
}
}
}
int AverageFavorCocienteGlobal(UserTorneo ut1,UserTorneo ut2){
if((ut2.getTantosFavor() - ut2.getTantosContra()) - (ut1.getTantosFavor()-ut1.getTantosContra())!= 0){ // Average global
return (ut2.getTantosFavor() - ut2.getTantosContra()) - (ut1.getTantosFavor()-ut1.getTantosContra());
}
else if(ut2.getTantosFavor() - ut1.getTantosFavor() != 0){ // Tantos a Favor global
return ut2.getTantosFavor() - ut1.getTantosFavor();
}
else{ // Cociente global
return (ut2.getTantosFavor()/ut2.getTantosContra()) - (ut1.getTantosFavor()/ut1.getTantosContra());
}
}
}
Faltaria por implementar el criterio de desempate cuando son más de 2 equipos que sería:
- Número de victorias en enfrentamientos directos (seguir repitiendo para los que sigan empatados)
- Average directo
- Tantos a favor en enfrentamientos directos
- Average global
- Tantos a favor global
- Cociente global