TreeMap จัดเรียงตามค่า

ฉันต้องการเขียนตัวเปรียบเทียบที่จะให้ฉันเรียงลำดับ TreeMap ตามค่าแทนการเรียงตามค่าเริ่มต้นตามธรรมชาติ

ฉันลองอะไรเช่นนี้ แต่ไม่สามารถหาสิ่งที่ผิดพลาดได้:

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

ฉันเดาว่าฉันกำลังถามอะไรอยู่: ฉันจะMap.Entryส่งผ่านไปยังตัวเปรียบเทียบได้หรือไม่

คุณไม่TreeMapสามารถเรียงลำดับค่าได้เองเนื่องจากมันเป็นไปตามSortedMapข้อกำหนด:

A Mapที่ให้การสั่งซื้อทั้งหมดบนกุญแจเพิ่มเติม

อย่างไรก็ตามเมื่อใช้คอลเล็กชันภายนอกคุณสามารถเรียงลำดับได้Map.entrySet()ตามต้องการทั้งคีย์ค่าหรือแม้แต่การรวมกัน (!!) ของทั้งสอง

นี่เป็นวิธีการทั่วไปที่ส่งกลับSortedSetของMap.Entryการให้Mapที่มีค่าเป็น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;
}

ตอนนี้คุณสามารถทำสิ่งต่อไปนี้:

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

โปรดทราบว่าสิ่งที่ขี้ขลาดจะเกิดขึ้นหากคุณพยายามปรับเปลี่ยนทั้งSortedSetตัวมันเองหรือMap.Entryภายในเพราะจะไม่เป็น "มุมมอง" ของแผนที่ดั้งเดิมเช่นentrySet()นั้นอีกต่อไป

โดยทั่วไปแล้วความต้องการในการเรียงลำดับรายการแผนที่ตามค่าของมันนั้นผิดปกติ

หมายเหตุ==สำหรับInteger

เปรียบเทียบเดิมของคุณเปรียบเทียบโดยใช้Integer ==นี้เกือบจะไม่ถูกต้องเสมอเนื่องจาก==มีIntegerตัวถูกดำเนินการเป็นความเสมอภาคอ้างอิงไม่คุ้มค่าเท่าเทียมกัน

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

คำถามที่เกี่ยวข้อง

• เมื่อเปรียบเทียบจำนวนเต็มสองตัวใน Java การไม่ทำกล่องอัตโนมัติเกิดขึ้นเมื่อใด (NO !!!)
• มันรับประกันว่าnew Integer(i) == iใน Java? (ใช่!!!)

คำตอบของ polygenelubricants นั้นเกือบจะสมบูรณ์แบบ มันมีข้อผิดพลาดที่สำคัญอย่างหนึ่ง มันจะไม่จัดการรายการแผนที่ที่มีค่าเหมือนกัน

รหัสนี้: ...

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

จะส่งออก:

ape:1
frog:2
pig:3

สังเกตว่าวัวของเราหายตัวไปอย่างไรเมื่อมันแบ่งปันค่า "1" กับลิงของเรา: O!

การแก้ไขโค้ดนี้จะแก้ไขปัญหาที่เกิดขึ้น:

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

ใน Java 8:

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

TreeMapถูกเสมอเรียงตามคีย์อะไรก็ได้ที่เป็นไปไม่ได้ A Comparatorช่วยให้คุณควบคุม วิธีการเรียงลำดับคีย์

หากคุณต้องการค่าที่เรียงคุณต้องแยกมันออกเป็นListและเรียงลำดับนั้น

สิ่งนี้ไม่สามารถทำได้โดยใช้ a Comparatorเนื่องจากจะได้รับคีย์ของแผนที่เพื่อเปรียบเทียบเสมอ TreeMapสามารถเรียงลำดับโดยคีย์เท่านั้น

คำตอบโอลอฟเป็นสิ่งที่ดี แต่ต้องเป็นหนึ่งในสิ่งที่มากขึ้นก่อนที่มันจะสมบูรณ์แบบ ในความคิดเห็นด้านล่างคำตอบของเขา dacwe (ถูกต้อง) ชี้ให้เห็นว่าการใช้งานของเขาละเมิดสัญญาเปรียบเทียบ / เท่ากับสำหรับชุด หากคุณพยายามโทรมีหรือลบรายการที่อยู่ในชุดอย่างชัดเจนชุดจะไม่รู้จักเนื่องจากรหัสที่อนุญาตให้วางรายการที่มีค่าเท่ากันในชุด ดังนั้นเพื่อแก้ไขปัญหานี้เราจำเป็นต้องทดสอบความเท่าเทียมกันระหว่างปุ่มต่างๆ:

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

"โปรดทราบว่าการเรียงลำดับที่บำรุงรักษาโดยชุดเรียง (ไม่ว่าจะมีการเปรียบเทียบอย่างชัดเจนหรือไม่ก็ตาม) จะต้องสอดคล้องกับเท่ากับหากชุดเรียงลำดับเพื่อนำอินเตอร์เฟส Set ไปใช้อย่างถูกต้อง ... ชุดอินเตอร์เฟสถูกกำหนดในแง่ของการดำเนินการเท่ากับ แต่ชุดที่เรียงลำดับดำเนินการเปรียบเทียบองค์ประกอบทั้งหมดโดยใช้การเปรียบเทียบ (หรือเปรียบเทียบ) วิธีดังนั้นสององค์ประกอบที่ถือว่าเท่าเทียมกันโดยวิธีนี้คือจากมุมมองของชุดการเรียงที่เท่ากัน " ( http://docs.oracle.com/javase/6/docs/api/java/util/SortedSet.html )

เนื่องจากเดิมเรามองข้ามความเสมอภาคเพื่อบังคับให้ชุดเพิ่มรายการที่มีคุณค่าเท่ากันตอนนี้เราต้องทดสอบความเท่าเทียมกันในคีย์เพื่อให้ชุดส่งคืนรายการที่คุณกำลังมองหา นี่เป็นเรื่องที่ค่อนข้างยุ่งและไม่แน่นอนว่าชุดจะถูกนำมาใช้อย่างไร - แต่มันก็ใช้ได้

ฉันรู้ว่าโพสต์นี้ขอเฉพาะการเรียงลำดับ TreeMap ตามค่า แต่สำหรับพวกเราที่ไม่สนใจเกี่ยวกับการนำไปใช้จริง ๆ แต่ต้องการโซลูชันที่ช่วยให้การรวบรวมเรียงลำดับตามองค์ประกอบที่เพิ่มเข้ามาฉันขอขอบคุณข้อเสนอแนะจาก TreeSet นี้ สารละลาย. สำหรับหนึ่งองค์ประกอบจะไม่สามารถเรียกคืนได้อย่างง่ายดายด้วยกุญแจ แต่สำหรับกรณีการใช้งานที่ฉันมีอยู่ในมือ (การค้นหาปุ่ม n ด้วยค่าต่ำสุด) นี่ไม่ใช่ข้อกำหนด

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

ผู้คนจำนวนมากได้ยินคำแนะนำให้ใช้ List และฉันก็ชอบที่จะใช้เช่นกัน

นี่คือสองวิธีที่คุณต้องเรียงลำดับรายการของแผนที่ตามค่าของพวกเขา

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