java - implementacion - ¿Cómo escribo un método compareTo que compara objetos?

implementacion compareto java

Question

Estoy aprendiendo acerca de las matrices, y básicamente tengo una matriz que recopila un apellido, nombre y puntaje.

Necesito escribir un método compareTo que compare el apellido y el nombre para que la lista se pueda ordenar alfabéticamente comenzando con los apellidos, y luego, si dos personas tienen el mismo apellido, entonces ordenarán el primer nombre.

Estoy confundido, porque toda la información en mi libro está comparando números, no objetos y cadenas.

Esto es lo que he codificado hasta ahora. Sé que está mal, pero al menos explica lo que creo que estoy haciendo:

public int compare(Object obj) // creating a method to compare 
{   
    Student s = (Student) obj; // creating a student object

    // I guess here I''m telling it to compare the last names?
    int studentCompare = this.lastName.compareTo(s.getLastName()); 

    if (studentCompare != 0)
        return studentCompare;
    else 
    {
        if (this.getLastName() < s.getLastName())
            return - 1;

        if (this.getLastName() > s.getLastName())
            return 1;
    }
    return 0;
}

Sé que los símbolos < y > están mal, pero como dije, mi libro solo muestra cómo usar el compareTo .

Answer 1

Considere usar la interfaz de Comparator que se describe here que usa genéricos para evitar el lanzamiento de Object to Student .

Como dijo Eugene Retunsky, su primera parte es la forma correcta de comparar String s. Además, si lastName s son iguales, creo que se proponía comparar firstName s, en cuyo caso simplemente use compareTo de la misma manera.

Answer 2

El método compareTo se describe de la siguiente manera:

Compara este objeto con el objeto especificado para ordenarlo. Devuelve un entero negativo, cero o un entero positivo ya que este objeto es menor, igual o mayor que el objeto especificado.

Digamos que nos gustaría comparar Jedis por su edad:

class Jedi implements Comparable<Jedi> {

    private final String name;
    private final int age;
        //...
}

Entonces, si nuestro Jedi es mayor que el proporcionado, debe devolver un resultado positivo, si tiene la misma edad, devuelve 0, y si nuestro Jedi es más joven, devuelve un resultado negativo.

public int compareTo(Jedi jedi){
    return this.age > jedi.age ? 1 : this.age < jedi.age ? -1 : 0;
}

Al implementar el método compareTo (proveniente de la interfaz Comparable ) estás definiendo lo que se llama un orden natural . Todos los métodos de clasificación en JDK usarán este orden por defecto .

Hay ocasiones en las que es posible que desee basar su comparación en otros objetos, y no en un tipo primitivo. Por ejemplo, copare Jedis basándose en sus nombres. En este caso, si los objetos que se comparan ya implementan Comparable entonces puede hacer la comparación utilizando su método compareTo .

public int compareTo(Jedi jedi){
    return this.name.compareTo(jedi.getName());
}

Sería más simple en este caso.

Ahora, si ingresaste para usar tanto el nombre como la edad como criterio de comparación, entonces tienes que decidir cuál es tu comparación, qué tiene prioridad. Por ejemplo, si dos Jedis reciben el mismo nombre, puedes usar su edad para decidir qué va primero y cuál va en segundo lugar.

public int compareTo(Jedi jedi){
    int result = this.name.compareTo(jedi.getName());
    if(result == 0){
        result = this.age > jedi.age ? 1 : this.age < jedi.age ? -1 : 0;
    }
    return result;
}

Si tuvieras una serie de Jedis

Jedi[] jediAcademy = {new Jedi("Obiwan",80), new Jedi("Anakin", 30), ..}

Todo lo que tienes que hacer es solicitar a la clase java.util.Arrays que use su método de clasificación.

Arrays.sort(jediAcademy);

Este método Arrays.sort usará su método compareTo para ordenar los objetos uno por uno.

Answer 3

Escucha a @milkplusvellocet, te recomendaría que implementes la interfaz Comparable también para tu clase.

Simplemente contribuyendo a las respuestas de los demás:

String.compareTo() le dirá qué tan diferente es una cadena de otra.

por ejemplo, System.out.println( "Test".compareTo("Tesu") ); imprimirá -1 y System.out.println( "Test".compareTo("Tesa") ); se imprimirá 19

y la solución nerdy y geek de una línea para esta tarea sería:

return this.lastName.equals(s.getLastName()) ? this.lastName.compareTo(s.getLastName()) : this.firstName.compareTo(s.getFirstName());

Explicación:

this.lastName.equals(s.getLastName()) comprueba si los apellidos son los mismos o no this.lastName.compareTo(s.getLastName()) caso afirmativo, luego devuelve la comparación del apellido. this.firstName.compareTo(s.getFirstName()) si no, devuelve la comparación del primer nombre.

Answer 4

Estás casi todo el camino hasta allí.

Sus primeras líneas, comparando el apellido, van por buen camino. El método compareTo () en la cadena devolverá un número negativo para una cadena en orden alfabético anterior, y un número positivo para una en orden alfabético después.

Ahora, solo necesita hacer lo mismo para su nombre y puntaje.

En otras palabras, si Apellido 1 == Apellido 2, vaya a verificar su nombre al lado. Si el primer nombre es el mismo, verifique su puntaje a continuación. (Piense en anidar sus bloques if / then).

Answer 5

Esta es la forma correcta de comparar cadenas:

int studentCompare = this.lastName.compareTo(s.getLastName()); 

Esto ni siquiera compilará

if (this.getLastName() < s.getLastName())

Use if (this.getLastName().compareTo(s.getLastName()) < 0) lugar.

Entonces, para comparar el orden puño / apellido que necesita:

int d = getFirstName().compareTo(s.getFirstName());
if (d == 0)
    d = getLastName().compareTo(s.getLastName());
return d;

Answer 6

No tendría un parámetro de tipo Object, no tiene sentido enviarlo a Student si sabemos que siempre será de tipo Student.

En cuanto a una explicación, "resultado == 0" solo ocurrirá cuando los apellidos sean idénticos, en ese punto comparamos los nombres y en su lugar devolvemos ese valor.

public int Compare(Object obj)
{       
    Student student = (Student) obj;
    int result = this.getLastName().compareTo( student.getLastName() );

    if ( result == 0 )
    {
        result = this.getFirstName().compareTo( student.getFirstName() );
    }

    return result;
}

Answer 7

Una cadena es un objeto en Java.

usted podría comparar así,

if(this.lastName.compareTo(s.getLastName() == 0)//last names are the same

Answer 8

if (s.compareTo(t) > 0) comparará la cadena s con la cadena t y devolverá el valor int que desee.

    public int Compare(Object obj) // creating a method to compare {   
        Student s = (Student) obj; //creating a student object

        // compare last names
        return  this.lastName.compareTo(s.getLastName());    
    }

Ahora solo prueba un retorno negativo positivo del método como lo harías normalmente.

Aclamaciones