TreeMap ordina per valore

Voglio scrivere un comparatore che mi permetta di ordinare una TreeMap in base al valore anziché all'ordinamento naturale predefinito.

Ho provato qualcosa del genere, ma non riesco a scoprire cosa è andato storto:

import java.util.*;

class treeMap {
    public static void main(String[] args) {
        System.out.println("the main");
        byValue cmp = new byValue();
        Map<String, Integer> map = new TreeMap<String, Integer>(cmp);
        map.put("de",10);
        map.put("ab", 20);
        map.put("a",5);

        for (Map.Entry<String,Integer> pair: map.entrySet()) {
            System.out.println(pair.getKey()+":"+pair.getValue());
        }
    }
}

class byValue implements Comparator<Map.Entry<String,Integer>> {
    public int compare(Map.Entry<String,Integer> e1, Map.Entry<String,Integer> e2) {
        if (e1.getValue() < e2.getValue()){
            return 1;
        } else if (e1.getValue() == e2.getValue()) {
            return 0;
        } else {
            return -1;
        }
    }
}

Immagino che cosa sto chiedendo è: posso ottenere un Map.Entrypassaggio al comparatore?

Non puoi avere lo TreeMapstesso ordinamento sui valori, poiché ciò sfida le SortedMapspecifiche:

A Mapche fornisce inoltre un ordinamento totale sulle sue chiavi .

Tuttavia, utilizzando una raccolta esterna, è sempre possibile ordinare Map.entrySet()come desiderato, in base a chiavi, valori o persino una combinazione (!!) dei due.

Ecco un metodo generico che restituisce un SortedSetdi Map.Entry, dato un i Mapcui valori sono Comparable:

static <K,V extends Comparable<? super V>>
SortedSet<Map.Entry<K,V>> entriesSortedByValues(Map<K,V> map) {
    SortedSet<Map.Entry<K,V>> sortedEntries = new TreeSet<Map.Entry<K,V>>(
        new Comparator<Map.Entry<K,V>>() {
            @Override public int compare(Map.Entry<K,V> e1, Map.Entry<K,V> e2) {
                int res = e1.getValue().compareTo(e2.getValue());
                return res != 0 ? res : 1;
            }
        }
    );
    sortedEntries.addAll(map.entrySet());
    return sortedEntries;
}

Ora puoi fare quanto segue:

    Map<String,Integer> map = new TreeMap<String,Integer>();
    map.put("A", 3);
    map.put("B", 2);
    map.put("C", 1);   

    System.out.println(map);
    // prints "{A=3, B=2, C=1}"
    System.out.println(entriesSortedByValues(map));
    // prints "[C=1, B=2, A=3]"

Nota che succederà qualcosa di strano se provi a modificare il SortedSetsé stesso o l' Map.Entryinterno, perché questa non è più una "vista" della mappa originale come entrySet()è.

In generale, la necessità di ordinare le voci di una mappa in base ai suoi valori è atipica.

Nota ==perInteger

Il tuo comparatore originale confronta Integerusando ==. Questo è quasi sempre sbagliato, poiché ==con gli Integeroperandi è un'uguaglianza di riferimento, non un'uguaglianza di valore.

    System.out.println(new Integer(0) == new Integer(0)); // prints "false"!!!

Domande correlate

• Quando si confrontano due numeri interi in Java si verifica l'auto-unboxing? (NO!!!)
• È garantito che new Integer(i) == iin Java? (SÌ!!!)

la risposta dei poligenelubrificanti è quasi perfetta. Ha un bug importante però. Non gestirà le voci della mappa in cui i valori sono gli stessi.

Questo codice: ...

Map<String, Integer> nonSortedMap = new HashMap<String, Integer>();
nonSortedMap.put("ape", 1);
nonSortedMap.put("pig", 3);
nonSortedMap.put("cow", 1);
nonSortedMap.put("frog", 2);

for (Entry<String, Integer> entry  : entriesSortedByValues(nonSortedMap)) {
    System.out.println(entry.getKey()+":"+entry.getValue());
}

Uscita:

ape:1
frog:2
pig:3

Nota come la nostra mucca è scomparsa mentre condivideva il valore "1" con la nostra scimmia: O!

Questa modifica del codice risolve questo problema:

static <K,V extends Comparable<? super V>> SortedSet<Map.Entry<K,V>> entriesSortedByValues(Map<K,V> map) {
        SortedSet<Map.Entry<K,V>> sortedEntries = new TreeSet<Map.Entry<K,V>>(
            new Comparator<Map.Entry<K,V>>() {
                @Override public int compare(Map.Entry<K,V> e1, Map.Entry<K,V> e2) {
                    int res = e1.getValue().compareTo(e2.getValue());
                    return res != 0 ? res : 1; // Special fix to preserve items with equal values
                }
            }
        );
        sortedEntries.addAll(map.entrySet());
        return sortedEntries;
    }

In Java 8:

LinkedHashMap<Integer, String> sortedMap = 
    map.entrySet().stream().
    sorted(Entry.comparingByValue()).
    collect(Collectors.toMap(Entry::getKey, Entry::getValue,
                             (e1, e2) -> e1, LinkedHashMap::new));

A TreeMapviene sempre ordinato in base alle chiavi, qualsiasi altra cosa è impossibile. A Comparatorconsente semplicemente di controllare il modo in cui le chiavi sono ordinate.

Se vuoi i valori ordinati, devi estrarli in a Liste ordinarli.

Questo non può essere fatto usando un Comparator, poiché otterrà sempre la chiave della mappa da confrontare. TreeMappuò solo ordinare in base alla chiave.

La risposta di Olof è buona, ma ha bisogno di un'altra cosa prima che sia perfetta. Nei commenti sotto la sua risposta, dacwe (correttamente) sottolinea che la sua implementazione viola il contratto Compare / Equals per i Set. Se si tenta di chiamare contiene o rimuove una voce che è chiaramente nel set, il set non lo riconoscerà a causa del codice che consente di inserire voci con valori uguali nel set. Quindi, per risolvere questo problema, dobbiamo verificare l'uguaglianza tra le chiavi:

static <K,V extends Comparable<? super V>> SortedSet<Map.Entry<K,V>> entriesSortedByValues(Map<K,V> map) {
    SortedSet<Map.Entry<K,V>> sortedEntries = new TreeSet<Map.Entry<K,V>>(
        new Comparator<Map.Entry<K,V>>() {
            @Override public int compare(Map.Entry<K,V> e1, Map.Entry<K,V> e2) {
                int res = e1.getValue().compareTo(e2.getValue());
                if (e1.getKey().equals(e2.getKey())) {
                    return res; // Code will now handle equality properly
                } else {
                    return res != 0 ? res : 1; // While still adding all entries
                }
            }
        }
    );
    sortedEntries.addAll(map.entrySet());
    return sortedEntries;
}

"Si noti che l'ordinamento gestito da un set ordinato (indipendentemente dal fatto che sia fornito o meno un comparatore esplicito) deve essere coerente con uguale se il set ordinato deve implementare correttamente l'interfaccia Set ... l'interfaccia Set viene definita in termini di operazione uguale , ma un set ordinato esegue tutti i confronti di elementi usando il suo metodo compareTo (o compare), quindi due elementi che sono considerati uguali da questo metodo sono, dal punto di vista del set ordinato, uguali . " ( http://docs.oracle.com/javase/6/docs/api/java/util/SortedSet.html )

Dato che inizialmente abbiamo trascurato l'uguaglianza per forzare l'insieme ad aggiungere voci di uguale valore, ora dobbiamo testare l'uguaglianza nelle chiavi affinché l'insieme restituisca effettivamente la voce che stai cercando. Questo è un po 'disordinato e sicuramente non è il modo in cui i set dovevano essere usati - ma funziona.

So che questo post richiede specificamente di ordinare una TreeMap in base ai valori, ma per quelli di noi che non si interessano molto all'implementazione ma vogliono una soluzione che mantenga la raccolta ordinata quando vengono aggiunti elementi, apprezzerei il feedback su questo TreeSet-based soluzione. Per uno, gli elementi non sono facilmente recuperabili dalla chiave, ma per il caso d'uso che avevo a portata di mano (trovare le chiavi n con i valori più bassi), questo non era un requisito.

  TreeSet<Map.Entry<Integer, Double>> set = new TreeSet<>(new Comparator<Map.Entry<Integer, Double>>()
  {
    @Override
    public int compare(Map.Entry<Integer, Double> o1, Map.Entry<Integer, Double> o2)
    {
      int valueComparison = o1.getValue().compareTo(o2.getValue());
      return valueComparison == 0 ? o1.getKey().compareTo(o2.getKey()) : valueComparison;
    }
  });
  int key = 5;
  double value = 1.0;
  set.add(new AbstractMap.SimpleEntry<>(key, value));

Molte persone sentono il consiglio di usare List e preferisco anche usarlo

qui ci sono due metodi necessari per ordinare le voci della mappa in base ai loro valori.

    static final Comparator<Entry<?, Double>> DOUBLE_VALUE_COMPARATOR = 
        new Comparator<Entry<?, Double>>() {
            @Override
            public int compare(Entry<?, Double> o1, Entry<?, Double> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
        };

        static final List<Entry<?, Double>> sortHashMapByDoubleValue(HashMap temp)
        {
            Set<Entry<?, Double>> entryOfMap = temp.entrySet();

            List<Entry<?, Double>> entries = new ArrayList<Entry<?, Double>>(entryOfMap);
            Collections.sort(entries, DOUBLE_VALUE_COMPARATOR);
            return entries;
        }