TreeMap classificar por valor

Quero escrever um comparador que permita classificar um TreeMap por valor, em vez da ordem natural padrão.

Eu tentei algo assim, mas não consigo descobrir o que deu errado:

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

Acho que o que estou perguntando é: Posso passar um Map.Entrypasse para o comparador?

Você não pode TreeMapclassificar os valores, pois isso desafia a SortedMapespecificação:

A Mapque fornece ainda um total de pedidos em suas chaves .

No entanto, usando uma coleção externa, você sempre pode classificar da maneira Map.entrySet()que desejar, por chaves, valores ou até mesmo uma combinação (!!) das duas.

Aqui está um método genérico que retorna um SortedSetde Map.Entry, dados a Mapcujos valores são 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;
}

Agora você pode fazer o seguinte:

    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]"

Observe que coisas descoladas acontecerão se você tentar modificar o SortedSetpróprio, ou o Map.Entryinterior, porque essa não é mais uma "visualização" do mapa original entrySet().

De um modo geral, a necessidade de classificar as entradas de um mapa por seus valores é atípica.

Nota ==paraInteger

Seu comparador original compara Integerusando ==. Isso quase sempre está errado, já que ==com Integeroperandos é uma igualdade de referência, não uma igualdade de valor.

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

Perguntas relacionadas

• Ao comparar dois números inteiros em Java, ocorre o desbloqueio automático? (NÃO!!!)
• É garantido que new Integer(i) == iem Java? (SIM!!!)

resposta de poligenelubricants é quase perfeita. Ele tem um bug importante. Ele não manipula entradas de mapa onde os valores são os mesmos.

Este código: ...

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

Saída:

ape:1
frog:2
pig:3

Observe como nossa vaca desapareceu ao compartilhar o valor "1" com o nosso macaco: O!

Esta modificação do código resolve esse 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;
    }

No 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 TreeMapé sempre classificado pelas teclas, qualquer outra coisa é impossível. A Comparatorapenas permite controlar como as chaves são classificadas.

Se você deseja que os valores classificados, você deve extraí-los Liste ordená- los .

Isso não pode ser feito usando a Comparator, pois ele sempre compara a chave do mapa. TreeMapsó pode classificar pela chave.

A resposta de Olof é boa, mas precisa de mais uma coisa antes de ser perfeita. Nos comentários abaixo de sua resposta, dacwe (corretamente) ressalta que sua implementação viola o contrato Compare / Igual a Conjuntos. Se você tentar chamar a opção contém ou remover uma entrada que esteja claramente no conjunto, o conjunto não o reconhecerá devido ao código que permite que entradas com valores iguais sejam colocadas no conjunto. Portanto, para corrigir isso, precisamos testar a igualdade entre as chaves:

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

"Observe que a ordem mantida por um conjunto classificado (se um comparador explícito é ou não fornecido) deve ser consistente com iguais se o conjunto classificado deve implementar corretamente a interface Set ... a interface Set é definida em termos da operação igual , mas um conjunto classificado executa todas as comparações de elementos usando seu método compareTo (ou compare), portanto, dois elementos que são considerados iguais por esse método são, do ponto de vista do conjunto classificado, iguais . " ( http://docs.oracle.com/javase/6/docs/api/java/util/SortedSet.html )

Como originalmente ignoramos a igualdade para forçar o conjunto a adicionar entradas com valores iguais, agora precisamos testar a igualdade nas chaves para que o conjunto realmente retorne a entrada que você está procurando. Isso é meio confuso e definitivamente não é como os aparelhos deveriam ser usados ​​- mas funciona.

Eu sei que este post pede especificamente a classificação de um TreeMap por valores, mas para aqueles que realmente não se importam com a implementação, mas desejam uma solução que mantenha a coleção classificada à medida que os elementos forem adicionados, eu gostaria de receber feedback sobre esse TreeSet baseado em solução. Por um lado, os elementos não são facilmente recuperados por chave, mas para o caso de uso que eu tinha em mãos (localizando as n chaves com os valores mais baixos), isso não era um 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));

Muitas pessoas ouvem conselhos para usar a Lista e eu prefiro usá-la também

Aqui estão dois métodos para ordenar as entradas do mapa de acordo com seus valores.

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