java - ordenar - Cómo usar la interfaz del Comparador

sort java example

Question

Soy nuevo en Java y realmente no entiendo cómo usar la interfaz del comparador. Tengo una lista de ArrayList de Item en una clase de Inventory y una clase de Item . En la clase de Item , escribí:

public class Item implements Comparator<Item> {
    //stuff
    ...
    @Override
    public int compare(Item a, Item b) {
        if (a.getID().compareToIgnoreCase(b.getID())>0)
            return 1;
        else if (a.getID().compareToIgnoreCase(b.getID())<0)
            return -1;
        else
            return 0;
    }
}

El método getID () simplemente da el id, que tengo que usar para alfabetizar los elementos. No estoy seguro de si esto es correcto, me hizo poner la anotación @Override , no estoy seguro de por qué. También escribí una interfaz que solo dice:

 public interface Comparator<Item>
{
    int compare(Item a, Item b);
}

No estoy seguro de eso. Además, ¿cómo implemento este método para ordenar el arraylist creado en la clase de inventario?

Gracias, si mi pregunta no tiene sentido o si necesita una aclaración solo házmelo saber.

Answer 1

El uso de la anotación @Override es una práctica estándar en editores como eclipse, netbeans para notificar al desarrollador que está anulando / implementando la clase padre / método de interfaz. Es opcional

No implemente esta interfaz en su clase de Artículo. Crea una nueva clase e implementa la interfaz de Comparator .

public class ItemCompare implements Comparator<Item> {

    @Override
    public int compare(Item a, Item b) {
        if (a.getID().compareToIgnoreCase(b.getID())>0)
            return 1;
        else if (a.getID().compareToIgnoreCase(b.getID())<0)
            return -1;
        return 0;
    }
} 

Y luego, en tu clase principal, haz esto:

ArrayList al = new ArrayList<Item>

Collections.sort(al, new ItemCompare())

Answer 2

Está mezclando las interfaces Comparator y Comparable .

Comparador: http://docs.oracle.com/javase/6/docs/api/java/util/Comparator.html

Comparable: http://docs.oracle.com/javase/6/docs/api/java/lang/Comparable.html

El propósito de Comparator es una clase (declarada de forma anónima in situ o de otro modo) que se puede pasar a una operación que necesita un pedido, y define el tipo que se utilizará en el artículo. El comparador se debe usar FUERA de la clase que necesita clasificación, si hay una forma alternativa de ordenarlo.

El propósito de Comparable es decir que la clase (que implementa Comparable) tiene un orden natural, y esto es lo que es. Si su clase que necesita clasificación tiene un orden natural, entonces defínalo como Comparable. (Una clase que implemente el orden de comparación de Comparable aún puede ser anulada por un Comparador. Por otro lado, si la clase no es Comparable además de pasar, es obligatorio que el Comparador sea posible).

Answer 3

Ha implementado la interfaz incorrecta, quiere Comparable

Answer 4

EDITAR: Primero que nada, un par de cosas:

1. La anotación @Override no debería ser obligatoria. Si Eclipse quiere que te lo pongas, no te preocupes.
2. No escriba su propia interfaz Comparator. Elimine esa definición NAO y use la proporcionada por Java. Reinventar la rueda probablemente viole el Código de Programación de la Computadora no hablada en aproximadamente 15 formas diferentes. Use import java.util.Comparator; en la parte superior de tu código (antes de las cosas de public class ) para a) usar la versión dada por Java yb) hacer que tu código sea compatible con casi todo lo demás que existe en el mundo.

La interfaz del Comparador no se usa para crear una clase que pueda ponerse en orden. Esta es la interfaz Comparable.

Ambos son similares, así que describiré ambos aquí.

java.util.Comparator

La interfaz del Comparador, como usted ya sabe, tiene un método: compare . El comparador es genérico (utiliza los corchetes angulares <> ) y toma el tipo que se comparará dentro de <> . El hecho es que los Comparadores se usan para comparar elementos de otras clases . Por ejemplo, podría crear un Comparador para java.lang.Integers que devuelva lo opuesto al "orden natural" (cómo se suelen ordenar los enteros).

Los comparadores se usan principalmente para dar a otros objetos una forma de ordenar sus parámetros cuando no están en orden natural. Por ejemplo, la clase java.util.TreeSet toma un Comparador para su capacidad de clasificación.

java.lang.Comparable

El propósito de Comparable es decir que un objeto puede ser comparado. También es genérico y toma el tipo con el que se puede comparar. Por ejemplo, un Comparable<String> se puede comparar con Strings.

Comparable tiene un método: compareTo() . A diferencia de Comparator''s compare() , compareTo toma un parámetro. Funciona como compare , excepto que usa el objeto invocado como un parámetro. Entonces, comparableA.compareTo(comparableB) es lo mismo que comparator.compare(comparableA, comparableB) .

Comparable en su mayoría establece el orden natural de los objetos, y es la forma predeterminada de comparar objetos. La función del comparador es anular este orden natural cuando se tienen necesidades diferentes de comparación o clasificación de datos.

ArrayList Sorting

Para ordenar una List , puede usar el método ya disponible: desplácese hacia abajo para sort en la clase java.util.Collections . Un método toma un Comparador, el otro no. sort es estático; use Collections.sort(...) , no Collections c = new Collections(); c.sort(...) Collections c = new Collections(); c.sort(...) . ( Collections ni siquiera tiene un constructor de todos modos, entonces meh .)

Answer 5

Para usar la interfaz Comparator , debe implementarla y pasarla como una clase anónima a Collections.sort (lista de lista, comparador c) como el segundo parámetro.

Si desea pasar solo la lista a Collections.sort (lista de lista), entonces su clase Item tiene que implementar la interfaz Comparable .

Entonces, en ambos casos, los métodos Collections.sort saben cómo ordenar los elementos en su lista

aquí hay un código de muestra:

Clase de artículo que implementa Inventario Comparable + que contiene una lista de artículos

public class Item implements Comparable<Item> {

    String id = null;

    public Item(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return id;
    }

    @Override
    public int compareTo(Item o) {
        return - id.compareToIgnoreCase(o.id);
    }
}


public class Inventory {

    List<Item> items = new ArrayList<>();

    public void addItem(Item item) {
        items.add(item);
    }

    public static void main(String[] args) {
        Inventory inventory = new Inventory();
        inventory.addItem(new Item("2"));
        inventory.addItem(new Item("4"));
        inventory.addItem(new Item("1"));
        inventory.addItem(new Item("7"));

        Collections.sort(inventory.items, new Comparator<Item>() {
            @Override
            public int compare(Item o1, Item o2) {
                return o1.id.compareToIgnoreCase(o2.id);
            }
        });
        System.out.println(inventory.items);

        Collections.sort(inventory.items);
        System.out.println(inventory.items);

    }
}

Salida

[1, 2, 4, 7] // ascending
[7, 4, 2, 1] // descending since the compareTo method inverts the sign of the comparison result.