Creare un compareTo per una Generica Classe che Implementa Comparable

Ho una Classe Generica con due variabili di tipo, che implementa java.lang.Comparabili.

public class DoubleKey<K,J> implementa Comparable<DoubleKey<K,J>>{ 

privato K key1; 
privato J key2; 

pubblico DoubleKey(K key1, J key2){ 
questo.key1 = key1; 
questo.key2 = key2; 
} 

pubblico K getFirstKey(){ 
la restituzione.key1; 
} 

pubblico J getSecondKey(){ 
la restituzione.key2; 
} 

//necessario per l'interfaccia Comparable 
public int compareTo(DoubleKey<K,J> questo ovviamente){ 
... 
} 

} 

Perché ho implementato con Comparabili, ho bisogno di scrivere il compareTo() metodo. Perché K, J possono essere di QUALSIASI tipo, sto avendo problemi su come confrontare le loro completamente. C’è un modo per essere in grado di catturare tutti i possibili tipi Primitivi, Wrapper, Oggetto di confronto? Grazie per l’aiuto!

InformationsquelleAutor Jairo | 2011-02-16

 

6 Replies
  1. 12

    quindi, per riassumere il detto di cui sopra e per il puzzle insieme in un codice di lavoro è questo:

        public class DoubleKey<K extends Comparable<K>, J extends Comparable<J>>
            implements Comparable<DoubleKey<K, J>> {
    
        private K key1;
        private J key2;
    
        public DoubleKey(K key1, J key2) {
            this.key1 = key1;
            this.key2 = key2;
        }
    
        public K getFirstKey() {
            return this.key1;
        }
    
        public J getSecondKey() {
            return this.key2;
        }
    
        public int compareTo(DoubleKey<K, J> that) {
    
            int cmp = this.getFirstKey().compareTo(that.getFirstKey());
            if (cmp == 0)
                cmp = this.getSecondKey().compareTo(that.getSecondKey());
            return cmp;
        }
    }
  2. 8

    Vorrebbe introdurre l’obbligo, che K e J hanno un ordinamento naturale che si può usare? In questo caso è possibile dichiarare la classe DoubleKey come questo:

    class DoubleKey<K extends Comparable<K>, J extends Comparable<J>>

    Quindi si possono definire le DoubleKey del compareTo come ti piace. Si possono fare cose come:

    getFirstKey().compareTo(aThat.getFirstKey())

    Non è possibile confrontare una qualsiasi istanza di K a un’istanza di J, però. Non c’è nessun ordinamento definito su quei tipi.

    Se questi tipi non devono necessariamente avere un ordinamento naturale (molti non lo fanno), si può prendere un Comparator<K> e Comparator<J> come parametri al costruttore dell’ DoubleKey. Una classe che fa questo già che è possibile utilizzare come esempio è Google Guava eccellente Le mappe di classe (vedi in particolare il newTreeMap metodi e i limiti dei tipi che accettano).

    • cosa significa getFirstKey().compareTo(questo ovviamente.getFirstKey()) restituisce quando 2 variabili sono uguali, e se non è uguale?
    • Questo è solo lo standard Comparable contratto. In a.compareTo(b), se sono uguali compareTo restituisce 0, se a < b restituisce un numero negativo (di solito -1), se a > b restituisce un numero positivo (di solito 1).
    • K extends Comparable<? super K> sarebbe meglio, perché si tratta di sottoclassi di Paragonabile classi in modo appropriato
  3. 4
    public class DoubleKey< 
    K implementa Comparable<B>, 
    J implementa Comparable<P>> 
    implementa Comparable<DoubleKey<K,J>> { 
    
    public int compareTo(DoubleKey<K,J>) { 
    int cmp = questo.key1.compareTo(che.key1); 
    se(cmp==0) cmp = questo.key2.compareTo(che.key2); 
    ritorno cmp; 
    } 
    } 
    
    • Non è K extends Comparable<K> invece di implements?
    • sì che è di destra. Tipo generico variabili possono solo extends, non implementare, anche se si tratta di un’interfaccia.
    • Perché K, J possono essere di TUTTI tipologia – non era che una precondizione?
    • K extends Comparable<? super K> sarebbe meglio, perché si tratta di sottoclassi di Paragonabile classi in modo appropriato
  4. 0

    Si dovrà definire una regola quando un DoubleKey<K,J> è più piccolo, più grande o uguale a questo. Che è quello che confrontare fa. Forse, questo è il mio attuale indovinare, non ha molto senso confrontare le istanze di DoubleKey<K,J>.

    Se non si cura vera e propria come sono ordinati e solo bisogno di implementare qualsiasi ordinazione, provate questo:

    public int compareTo(DoubleKey<K,J> that){
        //real codes needs checks for null values!
        return (this.key1.toString() + this.key2.toString()).compareTo(that.key1.toString() + that.key2.toString());
    }
    • Ma quindi è necessario assicurarsi di questo documento (che compareTo dipende dalla toString() delle parti), e che compareTo non è coerente equals.
    • Fa senso se si usa per esempio DoubleKey<String, Animali>. È quindi possibile utilizzare confrontare per confrontare i valori Oggetto di J come si voleva, a seconda che i campi sono in loro chiamando i loro propri metodi di confronto. Per esempio le dimensioni e il peso. In alternativa, ou potrebbe confrontare la chiave stringhe in ordine alfabetico. Tutti lo sviluppatore del tipo di dati astratto DoubleKey per implementare il comportamento di loro scelta e di documentare bene.
  5. 0

    Primo modo: utilizzare hashCodes, come

     public int compareTo(DoubleKey<K,J> aThat){
         getFirstKey().hashCode() + getSecondKey().hashCode() - aThat.getFirstKey().hashCode() +   aThat.getSecondKey().hashCode();
     }

    (si dovrebbe pensare di più su formula)

    Secondo modo:
    aggiungere comparatore per costruttore

    public DoubleKey(K key1, J key2, Comparator cmp){

Lascia un commento