Come utilizzare l'interfaccia di Comparator

Question

Sono nuovo di java e non riesco davvero a capire come utilizzare l'interfaccia di confronto. Possiedo un di Item s in una classe Inventory e una classe Item. Nella classe Item ho scritto:

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; 
    } 
} 

Il metodo getID() solo dà l'id, che devo usare per alfabetizzare gli articoli. Non sono sicuro che sia giusto, mi ha fatto mettere l'annotazione @Override, non so perché. Inoltre ho scritto un'interfaccia che dice solo:

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

Non sono sicuro di quel bit. Inoltre, come posso implementare questo metodo per ordinare l'arraylist creato nella classe di inventario?

Grazie, se la mia domanda non ha senso o necessita di chiarimenti fammelo sapere.

Answer 1

Per utilizzare l'interfaccia Comparator bisogna attuarla e passarlo come una classe anonima per Collections.sort(List list, Comparator c) come secondo parametro.

Se si desidera passare solo l'elenco a Collections.sort(List list), la classe Item ha l'interfaccia dell'attrezzo Comparable.

Quindi, in entrambi i casi i metodi Collections.sort sanno come ordinare gli elementi nel proprio elenco

Ecco qualche esempio di codice:

classe Item attuazione Comparable + inventario in possesso di un elenco di elementi

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); 

    } 
} 

Uscita

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

Answer 2

aver implementato l'interfaccia sbagliata, si vuole Comparable

Answer 3

si stia mescolando le interfacce Comparator e Comparable.

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

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

Lo scopo del comparatore è una classe (dichiarata in forma anonima sul posto o altro) che può essere passato a un'operazione che ha bisogno di un ordinamento, e definisce il ordinamento che verrà utilizzato sull'elemento. Il comparatore deve essere utilizzato ESTERNO alla classe che richiede l'ordinamento, se esiste un modo alternativo per il quale ordinare.

Lo scopo di Comparable è di dire che la classe (che implementa Comparable) ha un ordinamento naturale - e questo è quello che è. Se la classe che ha bisogno di ordinare ha un ordinamento naturale, quindi definirla come Paragonabile. (Una classe che implementa ordinamento paragonabile può ancora essere sovrascritto da un comparatore D'altra parte, se la classe non è paragonabile a passando anche un comparatore è obbligatoria per ordinare per essere possibile..)

Answer 4

EDIT: Prima di tutto, un paio di cose:

1. L'annotazione @Override non dovrebbe essere obbligatoria. Se Eclipse vuole che tu lo metta, non ti preoccupare.
2. Non scrivere la propria interfaccia comparatore. Elimina quella definizione NAO e usa quella fornita da Java. Reinventare la ruota probabilmente viola il Codice di programmazione informatico in circa 15 modi diversi. Utilizzare import java.util.Comparator; nella parte superiore del codice (prima del materiale public class) a) utilizzare la versione fornita da Java e b) rendere il codice compatibile con praticamente tutto il resto del mondo.

---

L'interfaccia comparatore non viene utilizzato per creare una classe che si può mettere in ordine. Questa è l'interfaccia comparabile.

Entrambi sono simili, quindi descriverò entrambi.

java.util.Comparator

L'interfaccia Comparator, come già sapete, ha un metodo: compare. Il comparatore è generico (usa le parentesi angolari <>) e prende il tipo che confronterà all'interno dello <>. Il fatto è che i Comparatori sono usati per confrontare gli articoli di altre classi. Ad esempio, potrei creare un Comparatore per java.lang.Integers che restituisce l'opposto dell '"ordine naturale" (come di solito vengono ordinati gli interi).

I comparatori vengono utilizzati principalmente per assegnare ad altri oggetti un modo per ordinare i loro parametri quando non sono in ordine naturale. Ad esempio, lo java.util.TreeSet class utilizza un comparatore per la sua capacità di ordinamento.

java.lang.Comparable

scopo paragonabile è quello di dire che un oggetto può essere paragonata. È anche generico e prende il tipo a cui può essere paragonato. Ad esempio, un Comparable<String> può essere paragonato a Stringhe.

Comparable ha un metodo: compareTo(). A differenza di Comparator compare(), compareTo accetta un parametro. Funziona come compare, tranne che utilizza l'oggetto di richiamo come un parametro. Quindi, comparableA.compareTo(comparableB) corrisponde a comparator.compare(comparableA, comparableB).

Paragonabile per lo più stabilisce l'ordine naturale per gli oggetti ed è il modo predefinito per confrontare gli oggetti. Il ruolo del comparatore è quello di ignorare questo ordine naturale quando si hanno esigenze diverse per il confronto o l'ordinamento dei dati.

ArrayList Ordinamento

Per ordinare un List, è possibile utilizzare il metodo già disponibili: scorrere verso il basso per sort sul java.util.Collections class. Un metodo prende un comparatore, l'altro no. sort è statico; utilizzare Collections.sort(...), non Collections c = new Collections(); c.sort(...). (Collections non ha nemmeno un costruttore comunque, quindi meh.)

Answer 5

L'utilizzo di @Override annotazione è una pratica standard in editor come Eclipse, NetBeans per notificare sviluppatore che è prevalente/attuazione classe padre/metodo di interfaccia. È opzionale

Non implementare questa interfaccia nella classe Elemento. Creare una classe nuova e implementare l'interfaccia 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; 
    } 
} 

E poi, nella classe principale, fare questo:

ArrayList al = new ArrayList<Item> 

Collections.sort(al, new ItemCompare())