TreeMap diurutkan berdasarkan nilai

Saya ingin menulis sebuah komparator yang akan membiarkan saya mengurutkan TreeMap berdasarkan nilai alih-alih pengurutan alami default.

Saya mencoba sesuatu seperti ini, tetapi tidak dapat menemukan apa yang salah:

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

Saya kira apa yang saya tanyakan adalah: Bisakah saya Map.Entrylulus ke komparator?

Anda tidak dapat TreeMapmengurutkan sendiri pada nilai, karena itu bertentangan dengan SortedMapspesifikasi:

A Mapyang selanjutnya memberikan pemesanan total pada kuncinya .

Namun, dengan menggunakan koleksi eksternal, Anda selalu dapat mengurutkan Map.entrySet()sesuka Anda, baik dengan kunci, nilai, atau bahkan kombinasi (!!) dari keduanya.

Berikut adalah metode umum yang mengembalikan SortedSetdari Map.Entry, Mapdengan nilai yang 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;
}

Sekarang Anda dapat melakukan hal berikut:

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

Perhatikan bahwa hal-hal yang funky akan terjadi jika Anda mencoba untuk memodifikasi baik SortedSetitu sendiri, atau di Map.Entrydalam, karena ini bukan lagi "tampilan" dari peta aslinya seperti entrySet()sekarang.

Secara umum, kebutuhan untuk mengurutkan entri peta berdasarkan nilainya tidak lazim.

Catatan ==untukInteger

Pembanding asli Anda membandingkan Integermenggunakan ==. Ini hampir selalu salah, karena ==dengan Integeroperan adalah persamaan referensi, bukan persamaan nilai.

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

Pertanyaan-pertanyaan Terkait

• Saat membandingkan dua Integer di Java, apakah unboxing otomatis terjadi? (TIDAK!!!)
• Apakah dijamin new Integer(i) == idi Jawa? (IYA!!!)

jawaban poligenelubricants hampir sempurna. Ini memiliki satu bug penting. Ini tidak akan menangani entri peta yang nilainya sama.

Kode ini: ...

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

Akan menghasilkan:

ape:1
frog:2
pig:3

Perhatikan bagaimana sapi kita menghilang karena berbagi nilai "1" dengan kera kita: O!

Modifikasi kode ini memecahkan masalah itu:

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

Di Jawa 8:

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

Sebuah TreeMapyang selalu diurutkan oleh kunci, hal lain adalah mustahil. A Comparatorhanya memungkinkan Anda untuk mengontrol bagaimana kunci diurutkan.

Jika Anda menginginkan nilai yang diurutkan, Anda harus mengekstraknya menjadi Listdan mengurutkan itu.

Ini tidak dapat dilakukan dengan menggunakan a Comparator, karena akan selalu mendapatkan kunci peta untuk dibandingkan. TreeMaphanya dapat mengurutkan berdasarkan kunci.

Jawaban Olof bagus, tapi butuh satu hal lagi sebelum sempurna. Dalam komentar di bawah jawabannya, dacwe (dengan benar) menunjukkan bahwa implementasinya melanggar kontrak Compare / Equals for Sets. Jika Anda mencoba memanggil berisi atau menghapus entri yang jelas di set, set tidak akan mengenalinya karena kode yang memungkinkan entri dengan nilai yang sama untuk ditempatkan di set. Jadi, untuk memperbaikinya, kita perlu menguji kesetaraan antara kunci:

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

"Perhatikan bahwa pengurutan yang dipelihara oleh himpunan yang diurutkan (apakah ada atau tidak pembanding eksplisit disediakan) harus konsisten dengan sama jika himpunan yang diurutkan adalah untuk mengimplementasikan antarmuka Set dengan benar ... antarmuka Set didefinisikan dalam istilah operasi yang sama , tetapi set yang diurutkan melakukan semua perbandingan elemen menggunakan metode bandingkanTo (atau bandingkan), jadi dua elemen yang dianggap sama dengan metode ini, dari sudut pandang set yang diurutkan, adalah sama . " ( http://docs.oracle.com/javase/6/docs/api/java/util/SortedSet.html )

Karena awalnya kita mengabaikan persamaan untuk memaksa himpunan menambahkan entri bernilai sama, sekarang kita harus menguji kesetaraan di kunci agar himpunan benar-benar mengembalikan entri yang Anda cari. Ini agak berantakan dan jelas bukan set yang dimaksudkan untuk digunakan - tetapi berhasil.

Saya tahu posting ini secara khusus meminta penyortiran TreeMap berdasarkan nilai, tetapi bagi kita yang tidak terlalu peduli dengan implementasi tetapi menginginkan solusi yang membuat koleksi tetap diurutkan saat elemen ditambahkan, saya akan menghargai umpan balik pada TreeSet berbasis larutan. Untuk satu, elemen tidak mudah diambil oleh kunci, tetapi untuk kasus penggunaan yang saya miliki (menemukan kunci n dengan nilai terendah), ini bukan persyaratan.

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

Banyak orang mendengar anjuran untuk menggunakan List dan saya lebih suka menggunakannya juga

berikut adalah dua metode yang Anda perlukan untuk mengurutkan entri Peta menurut nilainya.

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

import java.util.*;

public class Main {

public static void main(String[] args) {
    TreeMap<String, Integer> initTree = new TreeMap();
    initTree.put("D", 0);
    initTree.put("C", -3);
    initTree.put("A", 43);
    initTree.put("B", 32);
    System.out.println("Sorted by keys:");
    System.out.println(initTree);
    List list = new ArrayList(initTree.entrySet());
    Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
        @Override
        public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) {
            return e1.getValue().compareTo(e2.getValue());
        }
    });
    System.out.println("Sorted by values:");
    System.out.println(list);
}
}