Java: SortedMap, Diagramma Ad Albero, Paragonabile? Come si utilizza?

Ho una lista di oggetti di cui ho bisogno per ordinare in base alle proprietà di uno dei loro campi. Ho sentito dire che SortedMap e Comparatori sono il modo migliore per fare questo.

  1. Devo implementare Comparabile con la classe sono di ordinamento, o faccio a creare una nuova classe?
  2. Come faccio a creare un’istanza del SortedMap e passare il Comparatore?
  3. Come funziona il lavoro di selezione? Verrà automaticamente sorta di tutto, come nuovi oggetti sono inseriti?

EDIT:
Questo codice mi da un errore:

private TreeMap<Ktr> collection = new TreeMap<Ktr>();

(Ktr implementa Comparator<Ktr>). Eclipse dice che è in attesa di qualcosa di simile TreeMap<K, V>, in modo che il numero di parametri sto fornitura non è corretto.

Avete bisogno di un TreeSet, non di un diagramma ad albero.

OriginaleL’autore Nick Heiner | 2009-09-17

5 Replies
  1. 7
    1. Il modo più semplice è quello di implementare Comparable con i vostri oggetti esistenti, anche se si potrebbe invece creare un Comparator e la passa al SortedMap.

      Nota che Paragonabile e Comparatore sono due cose diverse; una classe che implementa Comparable confronta this a un altro oggetto, mentre una classe che implementa Comparator confronta due altri oggetti.
    2. Se si implementa Comparable, non c’è bisogno di passare niente di speciale nel costruttore. Basta chiamare new TreeMap<MyObject>(). (Edit: Tranne che, naturalmente, Maps bisogno di due parametri generici, non uno. Stupido me!)

      Se invece di creare un’altra classe che implementa Comparator, passare un’istanza di tale classe al costruttore.
    3. Sì, secondo il TreeMap Javadoc.

    Edit: rileggendo la domanda, niente di tutto questo ha senso. Se si dispone già di un elenco, la cosa più sensata da fare è implementare Comparable e quindi chiamare Collezioni.sort su di esso. Le mappe non sono necessarie.

    Un po ‘ di codice:

    public class MyObject implements Comparable<MyObject> {
        //... your existing code here ...
        @Override
        public int compareTo(MyObject other) {
            //do smart things here
        }
    }
    
    //Elsewhere:
    List<MyObject> list = ...;
    Collections.sort(list);

    Come con il SortedMap, si potrebbe invece creare un Comparator<MyObject> e la passa al Collezioni.sort(List, Comparatore).

    Puoi chiarire cosa intendi? Io vorrei implementare Comparabili con la lista anziché alla classe di corso di ordinamento?

    OriginaleL’autore Michael Myers

  2. 2

    1.

    Che dipende dalla situazione. Diciamo che l’oggetto dovrebbe ordinare prima che l’oggetto B nel vostro set. Se in generale ha senso considerare minore di B, allora realizzazione di analoghi avrebbe senso. Se l’ordine ha senso solo nel contesto in cui si utilizza il set, quindi probabilmente si dovrebbe creare un Comparatore.

    2.

    new TreeMap(new MyComparator());

    O senza la creazione di un MyComparator classe:

    new TreeMap(new Comparator<MyClass>() {
        int compare(MyClass o1, MyClass o2) { ... }
    });

    3. Sì.

    OriginaleL’autore sepp2k

  3. 1

    Dal momento che si dispone di un elenco e di ottenere un errore, in quanto si dispone di un argomento sulla mappa, suppongo che si desidera un set ordinato:

    SortedSet<Ktr> set = new TreeSet<Ktr>(comparator);

    Questo per evitare il set ordinati, cioè un iteratore restituirà gli elementi nel loro ordinamento. Ci sono anche metodi specifici per SortedSet che si potrebbe desiderare di utilizzare. Se anche voi volete tornare indietro, è possibile utilizzare NavigableSet.

    OriginaleL’autore starblue

  4. 0

    La mia risposta presuppone che si utilizza il TreeMap attuazione di SortedMap.

    1.) Se si utilizza TreeMap, avete una scelta. È possibile implementare Comparable direttamente nella tua classe o di passare un separato Comparator al costruttore.

    2.) Esempio:

    Comparator<A> cmp = new MyComparator();
    Map<A,B> map = new TreeMap<A,B>(myComparator);

    3.) Sì, questo è corretto. Internamente Diagramma ad albero utilizza un albero rosso-nero per memorizzare gli elementi nell’ordine in cui sono inseriti; il costo di tempo di esecuzione di un’istruzione insert (o di recupero) è O(log N).

    OriginaleL’autore Adamski

  5. 0

    Fare un Comparator<ClassYouWantToSort>. Quindi il Comparatore confronta il campo che si desidera ordinare.

    Quando si crea il TreeMap, si crea un TreeMap<ClassYouWantToSort>, e si passa il Comparator come argomento. Quindi, come potete inserire gli oggetti di tipo ClassYouWantToSort, il TreeMap utilizza il Comparator per ordinare in modo corretto.

    EDIT: Come Adamski note, si può anche fare ClassYouWantToSort stesso Comparable. Il vantaggio è che si dispone di un minor numero di classi da affrontare, il codice è più semplice, e ClassYouWantToSort ottiene un comodo ordinamento predefinito. Lo svantaggio è che ClassYouWantToSort non può avere un singolo ovvio ordinamento, e quindi dovrete implementare Comparables per altre situazioni comunque. Si può anche non essere in grado di cambiare ClassYouWantToSort.

    EDIT2: Se hai solo un mucchio di oggetti che si sta lanciando nella collezione, e non è un Map (ovvero non è un mapping da un insieme di oggetti per un altro), poi si desidera un TreeSet, non TreeMap.

    OriginaleL’autore jprete

Lascia un commento