ordenar objetos interface Comparable y método compareTo Java ejemplo CU00913C

[lealivan009]

Hola!! quisiera saber como resolvieron el ejercicio de ordenar las edades? Ejercicio CU00913C del curso avanzado de programación Java.

Yo lo hice así:
 

Código: [Seleccionar]

CLASE MAIN
////////////////////////////////////
package practica1;

import java.util.ArrayList;

import java.util.List;

public class Main3
{
    public static void main(String[]args)
    {
    Test2 p1=new Test2("Mario", 187, 22);
    Test2 p2=new Test2("Pepe", 173, 52);
    Test2 p3=new Test2("Manuel",158,27);
    Test2 p4=new Test2("David", 164, 25);
    Test2 p5=new Test2("Alberto", 184, 80);
   
    List <Test2> l=new ArrayList<>();
    l.add(p1);
    l.add(p2);
    l.add(p3);
    l.add(p4);
    l.add(p5);
   
        System.out.println("Orden inicial");
        for (int i = 0; i < l.size(); i++)
        {
            System.out.println(i+1+" - "+l.get(i).getNombre()+", "+l.get(i).getAltura()+", "+l.get(i).getEdad());   
        }
   
        System.out.println("Ordenados por altura");
        for (int i = 0; i < l.size(); i++)
        {
            int contador=1;
           
            for (int j = 0; j < l.size(); j++)
            {
             if(l.get(i).compareTo(l.get(j))==-1)
             {
             contador++;
             }
               
            }
            System.out.println(contador+" - "+l.get(i).getNombre()+", "+l.get(i).getAltura()+", "+l.get(i).getEdad());
           
   
        }
        System.out.println("Ordenado por edad");
        for (int i = 0; i < l.size(); i++)
        {
        int contador=1;
            for (int j = 0; j < l.size(); j++)
            {
                if (l.get(i).compareToEdad(l.get(j))==-1)
                {
                    contador++;
                }
             
           
            }
            System.out.println(contador+" - "+l.get(i).getNombre()+", "+l.get(i).getAltura()+", "+l.get(i).getEdad());
        }
   
     
       
    }
}
///////////////////////
CLASE QUE LLEVA LOS ATRIBUTOS
//////////////////////

package practica1;

public class Test2 implements Comparable<Test2>
{
   private String nombre;
   private int altura;
   private int edad;
   
   public Test2(String n, int a, int e)
   {
   this.nombre=n;
   this.altura=a;
   this.edad=e;
   }
   
   public int compareTo(Test2 t)
   {
   int resultado=0;
   if(this.altura>t.altura){resultado=1;}
   else if(this.altura<t.altura){resultado=-1;}
   else {resultado=0;}
   
   return resultado;
   }
   
   public int compareToEdad(Test2 t)
   {
   int resultado=0;
   if(this.edad>t.edad){resultado=1;}
   else if(this.edad<t.edad){resultado=-1;}
   else{resultado=0;}
   return resultado;
   }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getAltura() {
        return altura;
    }

    public void setAltura(int altura) {
        this.altura = altura;
    }

    public int getEdad() {
        return edad;
    }

    public void setEdad(int edad) {
        this.edad = edad;
    }
   
   
}
//////////////////////
RESULTADO
/////////////////////
Orden inicial
1 - Mario, 187, 22
2 - Pepe, 173, 52
3 - Manuel, 158, 27
4 - David, 164, 25
5 - Alberto, 184, 80
Ordenados por altura
1 - Mario, 187, 22
3 - Pepe, 173, 52
5 - Manuel, 158, 27
4 - David, 164, 25
2 - Alberto, 184, 80
Ordenado por edad
5 - Mario, 187, 22
2 - Pepe, 173, 52
3 - Manuel, 158, 27
4 - David, 164, 25
1 - Alberto, 184, 80
Pero no se si era de esa forma que habia que hacerlo! y como se podria hacer para q me aparecieran ordenados por posiciones(de mayor a menor) y no solo x el indice

[ESOJ]

Hola lealivan009 .

Yo lo hice así:

Código: [Seleccionar]

public class Persona implements Comparable<Persona> {

    private String nombre;
    private int edad, altura,condicionDeComparacion;
   
    public Persona(String nombre, int edad, int altura,int condicionDeComparacion) {
        this.nombre = nombre;
        this.edad = edad;
        this.altura = altura;
        this.condicionDeComparacion=condicionDeComparacion;
    }
    public String getNombre(){return nombre;}
    public int getEdad(){return edad;}
    public int getAltura(){return altura;}
    @Override
    public int compareTo(Persona o) {       
        if ( condicionDeComparacion==1){
            if (altura < o.altura) {
                return 1;
            }
            if (altura > o.altura) {
                return -1;
            }
        }
        if ( condicionDeComparacion==2){
            if (edad < o.edad) {
                return 1;
            }
            if (edad > o.edad) {
                return -1;
            }
        }
        return 0;
    }
}

Código: [Seleccionar]

import java.util.Arrays;

public class MainClass {

    public static void main(String[] args) {
        MainClass p =new MainClass();
        for (int i=1;i<3;i++) {
            Persona[] arrayPersonas= new Persona[5];
            arrayPersonas[0] = new Persona("Mario", 22, 187,i);
            arrayPersonas[1] = new Persona("Pepe", 52, 173,i);
            arrayPersonas[2] = new Persona("Manuel", 27, 158,i);
            arrayPersonas[3] = new Persona("David", 25, 164,i);
            arrayPersonas[4] = new Persona("Alberto", 80, 184,i);   
            if (i==1){
                System.out.println("Array sin ordenar ");
                p.imprimeArrayPersonas(arrayPersonas);}

            Arrays.sort(arrayPersonas);
            if (i==1){
                System.out.println("Array ordenado por altura");
            }
            if (i==2){
                System.out.println("Array ordenado por edad");
            }
            p.imprimeArrayPersonas(arrayPersonas);
        }
    }

    public void imprimeArrayPersonas(Persona[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println((i+1) + ". " + array[i].getNombre() + " - Altura: " + array[i].getAltura() + " - Edad: " + array[i].getEdad());
        }
    }
}
Espero que te sirva.
Un saludo.

[Erik_Escriche]

ESOJ, me gusta como has resuelto el compareTo() de la clase Persona. A mí no se me ocurría una forma de meter ambas comparaciones en el mismo método y tuve que crear dos distintos.

Hay algo que no comprendo. Veo que en la clase principal creas dos listas con el for. ¿Cómo puede saber el programa cuál de las dos tiene que ordenar por altura y cuál por edad? Sé que has introducido una variable condicionDeComparacion, pero la usas solo en el compareTo(). ¿El método compareTo() está relacionado de alguna forma con el sort() y por eso no necesitas invocar al primero en la clase principal?

Lealivan009, al principio intenté usar, como tú, los ArrayList para resolver el ejercicio, pero no encontraba la forma de decirle al programa dónde situar a cada elemento dentro de la lista, así que al final lo he hecho con arrays estáticos. Te dejo mi solución, pero no estoy satisfecho porque, aunque con los datos del ejemplo funciona bien, si una persona tiene la misma altura o peso que otra el programa falla:

Código: [Seleccionar]

package javaAvanzado;
public class Persona3 implements Comparable <Persona3> {
    //Atributos.
    private int altura;
    private int peso;
    private String nombre;
    //Constructor.
    public Persona3 (String nombre, int altura, int peso) {
        this.nombre=nombre;
        this.altura=altura;
        this.peso=peso;
    }
   
    public int compareTo (Persona3 persona) {
        int resultadoAltura;
        if (this.altura>persona.altura) { resultadoAltura = 1; }
        else if (this.altura<persona.altura) { resultadoAltura = -1; }
        else { resultadoAltura = 0; }       
        return resultadoAltura;
    }

    public int compareToPeso (Persona3 persona) {
        int resultadoPeso;
        if (this.peso>persona.peso) { resultadoPeso = 1; }
        else if (this.peso<persona.peso) { resultadoPeso = -1; }
        else {resultadoPeso=0;}
        return resultadoPeso;
    }
   
    public String toString() {
        String resultado;
        resultado = "Nombre: "+nombre+". Altura: "+altura+". Peso: "+peso+".";
        return resultado;
    }
}

Código: [Seleccionar]

package javaAvanzado;
public class MainPersona3 {
    public static void main (String [] args) {
        Persona3 [] listaSinOrdenar = new Persona3 [6];
        Persona3 [] listaAltura = new Persona3 [6];
        Persona3 [] listaPeso = new Persona3 [6];
        listaSinOrdenar[0] = new Persona3 ("Mario", 187, 89);
        listaSinOrdenar[1] = new Persona3 ("Pepe", 173, 60);
        listaSinOrdenar[2] = new Persona3 ("Manuel", 158, 70);
        listaSinOrdenar[3] = new Persona3 ("David", 164, 79);
        listaSinOrdenar[4] = new Persona3 ("Alberto", 184, 55);
        listaSinOrdenar[5] = new Persona3 ("Luis", 174, 56);
       
        System.out.println ("1. Lista sin ordenar.");
        for (int i = 0; i <listaSinOrdenar.length; i++) {           
            System.out.println (listaSinOrdenar[i].toString());
        }
       
        int posicion=5;
        for (int j = 0; j <listaSinOrdenar.length; j++) {
            for (int i = 0; i<listaSinOrdenar.length; i++) {
                if (listaSinOrdenar[j].compareTo(listaSinOrdenar[i])>0) {posicion=posicion-1;}
            }           
            listaAltura[posicion]=listaSinOrdenar[j];
            posicion=5;}       
       
        for (int j = 0; j <listaSinOrdenar.length; j++) {
            for (int i = 0; i<listaSinOrdenar.length; i++) {
                if (listaSinOrdenar[j].compareToPeso(listaSinOrdenar[i])>0) {posicion=posicion-1;}
            }           
            listaPeso[posicion]=listaSinOrdenar[j];
            posicion=5;}
           
        System.out.println ("2. Lista ordenada por altura.");
        for (int i = 0; i <listaAltura.length; i++) {
            System.out.println (listaAltura[i].toString());
        }
       
        System.out.println ("3. Lista ordenada por peso.");
        for (int i = 0; i <listaPeso.length; i++) {
            System.out.println (listaPeso[i].toString());
        }
    }
}

[ESOJ]

Buenos días.

El método sort() ordenará el Array según el criterío de comparación del método compareTo().

Tenemos por tanto la misma clase Persona con sus atributos dni y edad que son valores enteros. Ahora vamos a implementar la interfaz Comparable y para ello estamos obligados a implementar (sobreescribir) el método public int compareTo(Persona o).

Tu al crear el método compareToPeso() no estas implementando el método compareTo().Estas creando uno nuevo.


Un saludo.

[Erik_Escriche]

Gracias por lo del sort (). Modificaré el código para probar a hacerlo usando ese método. Parece muy útil.

Sí, sé que solo he implementado el método compareTo() para resolver la parte de las alturas. No sabía cómo comparar dos cosas distintas con un solo método hasta que vi tu resolución del ejercicio.

Muchas gracias por responder.

[brix]

Ejericio LINDO y un poco complicado porque <Comparable> se puede usar por ALTURA  pero luego por EDAD es una cosa chunguissima !  de toda forma SEÑORES y SEÑORAS os envio mi idea de solucion --> que no se para NADA buena .. pero FUNCIONA ! !

Código: [Seleccionar]

public class Main extends Persona {
    public static void main(String [] args){
        //aquy lo hago con un array
        // yo queria hacer sia x edad que por altura desde
        // este array
        Persona[] p1 = {new Persona("Mario",187,22),
                         new Persona("Pepe",173,52),
                         new Persona("Manuel",158,27),   
                         new Persona("David",164,25),
                         new Persona("Alberto",184,80),
                        };
        // este contador sirve para poner el numerito ..ahahahah
        int contador = 0;
        System.out.print("Personas sin ordenar"+"\n");
        for (int i = 0; i < p1.length; i++) {
            contador++;
            System.out.print(contador+" ");
            p1[i].visual();
        }
        //[b]LA Burbuja -- ]DARABUKA -- [/b]
       Ordenar.ordenar(p1);
       int contador2 = 0;
        System.out.print("\n"+"Personas orden por altura"+"\n");
        for (int i = 0; i < p1.length; i++) {
            contador2++;
            System.out.print(contador2+" ");
            p1[i].visual();
        }
        System.out.print("\n"+"Personas orden por EDAD--ME COSTO MUCHO"+"\n");
        int contador3 = 0;
        for (int i = 0; i < p1.length; i++){
            contador3++;
             p1[i].ordenaPorEdad(p1);
             System.out.println(p1[i]);
        }
}
}

---------------------------------------------------------------------------------------------
PERSONA
----------------------------------------------------------------------------------------------
public  class Persona implements Comparable<Persona> {
    private String nombre;
    private int edad, altura;
   
    public Persona(String nuevoNombre,int nuevaAltura, int nuvaEdad){
        this.nombre = nuevoNombre;
        if ((nuvaEdad >= 0) && (nuvaEdad < Short.MAX_VALUE)) this.edad = nuvaEdad;
        if ((nuevaAltura >= 0) && (nuevaAltura < Short.MAX_VALUE)) this.altura = nuevaAltura;
    }
   
    //public Persona(Persona[] p){
       
    //}
   
    public Persona(Persona p){
        this(p.nombre,p.edad,p.altura);
    }
    public Persona(){}
   
    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getEdad() {
        return edad;
    }
    //esto es para coprovar si se puede cambiar edad
    public void setEdad(int nuevaEdad) {
        edad = nuevaEdad;
    }

    public int getAltura() {
        return altura;
    }

    public void setAltura(int altura) {
        this.altura = altura;
    }
   
    @Override
    public int compareTo(Persona per){
        if(this.getAltura() > per.getAltura()) { return 1; }
        else if(this.getAltura() < per.getAltura()){ return -1; }
        else return 0;
    }
   
    public void visual(){
        System.out.println(toString());
        //String s = nombre.toString() + " - " + "Altura: " + altura + " - " + "Edad :" + " - " + edad;
    }
     
    @Override
    public String toString(){
        String s = nombre + " - " + "Altura: " + altura + " - " + "Edad :" + " - " + edad;
        return s;
    }
   
    public Persona[] ordenaPorEdad(Persona[] p1){
       Persona[] aux = new Persona[5];
       Persona p3 = new Persona();
       int c = 0;
     [b]  for (int i = 0; i < p1.length; i++){
           for(int j = i + 1; j < p1.length; j++){
               c++;
              if(p1[i].getEdad() > p1[j].getEdad()){
                   p3 = p1[i];
                   p1[i] = p1[j];
                   p1[j] = p3;[/b]
                   
                  [b] for(int n = 0; n < aux.length; n++){
                   aux[n]=p3;[/b]
                   //c++;
                   //System.out.print("\n"+ c +" "+aux);
                }
              }
           }
           //c++;  toda estas son la prueva que he echo !!!
           //for(int n = 0; n < aux.length; n++){
             //  System.out.print("\n"+c+" "+aux);
           }
           //System.out.print("\n"+c+" "+p3);  toda estas son la prueva que he echo !!!
     [b]  return aux;  [/b]
        }
        //return aux; toda estas son la prueva que he echo !!!
       }

--------------------------------------------------------------------------------------------------------------------
ORDENAR <Comparable> esta aquy ...mas o menos
-------------------------------------------------------------------------------------------------------------------


public  class Ordenar {
    /**
     *
     * @param p Persona
     */
    public static void ordenar(Comparable[] p){
      for(int i = 0; i < p.length; i++){
           for (int j = 0; j < p.length; j++){
              [b] if (p[i].compareTo(p[j])==-1){[/b]
                 [b]  Comparable c = p[i];[/b]
                   p[i]=p[j];
                   p[j]=c;
               }
           }
        }
     }
}
-----------------------------------------
------------------------------------------
-----------------------------------------
-----------------------------------------
Personas sin ordenar
1 Mario - Altura: 187 - Edad : - 22
2 Pepe - Altura: 173 - Edad : - 52
3 Manuel - Altura: 158 - Edad : - 27
4 David - Altura: 164 - Edad : - 25
5 Alberto - Altura: 184 - Edad : - 80

Personas orden por altura
1 Manuel - Altura: 158 - Edad : - 27
2 David - Altura: 164 - Edad : - 25
3 Pepe - Altura: 173 - Edad : - 52
4 Alberto - Altura: 184 - Edad : - 80
5 Mario - Altura: 187 - Edad : - 22

Personas orden por EDAD--ME COSTO MUCHO
Mario - Altura: 187 - Edad : - 22
David - Altura: 164 - Edad : - 25
Manuel - Altura: 158 - Edad : - 27
Pepe - Altura: 173 - Edad : - 52
Alberto - Altura: 184 - Edad : - 80
BUILD SUCCESSFUL (total time: 0 seconds)

[luxferre]

Una vez aprendido los conceptos básicos de ordenamiento con el compareTo, se puede hacer uso del framework Collections y su método sort, el cual recibe la lista y ordena según la implementación del método compareTo. Esta es mi implementación:

Código: [Seleccionar]

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class CollectionsCompareTo {

public static void main(String[] args) {

List<Persona> list = new ArrayList<>();

Persona per0 = new Persona("Mario", 187, 22);
list.add(per0);
Persona per1 = new Persona("Pepe", 173, 52);
list.add(per1);
Persona per2 = new Persona("Manuel", 158, 27);
list.add(per2);
Persona per3 = new Persona("David", 164, 25);
list.add(per3);
Persona per4 = new Persona("Alberto", 184, 80);
list.add(per4);

System.out.println("Sin ordenar");
for (int i = 0; i < 5; i++) {
System.out.println(list.get(i));
}

Collections.sort(list);
System.out.println();
System.out.println("Ordenado");
for (int i = 0; i < 5; i++) {
System.out.println(list.get(i));
}

}

public static class Persona implements Comparable<Persona> {

public String nombre;
public int altura;
public int edad;

public Persona(String nombre, int altura, int edad) {
this.nombre = nombre;
this.altura = altura;
this.edad = edad;
}

@Override
public String toString() {
return nombre + " - Altura: " + altura + " - Edad: " + edad;
}

@Override
public int compareTo(Persona o) {

// primer campo para ordenar : ALTURA
// Si quisiese que fuese por la edad se colocaria primero
if (this.altura != o.altura) {  // ICPC Rule (Basado en la implementación usada para programación competitiva)
return o.altura - altura;

// Si las alturas son iguales evalua esta condición
} else if (edad != o.edad) {
return edad - o.edad;
} else { // si la edad y la altura es igual
return 0;
}
}

}
}