在java中排序2d數據結構

Question

我需要按值對2d鍵/值對進行排序。 我已經在網上閱讀了很多關於這個的參考資料，並且最終編寫了我自己的類來使用HashMaps（見下文）。 我將代碼放入一個精簡的工作類中，用最少量的代碼重現問題，這樣您就可以將其剪切並粘貼到IDE中以進行快速診斷。

正如您所看到的，我編寫的方法是在將值輸入sortedMap之前正確對值進行排序。 但是，出於某種原因，當我嘗試隨后迭代sortedMap時，它們的值再次以不同的方式排序。

任何人都可以告訴我如何修復下面的代碼，以便迭代生成的2D數據對象，以降序為我提供數據？

---

編輯：使用TreeMaps重寫，我仍然遇到類似的問題。 這是重寫的代碼：

import java.util.*;

public class HashMapDemo {
    public static void main(String args[]) {

        // Code that creates and populates the unordered HashMap:
        TreeMap<Integer, Double> unSortedMap = new TreeMap<Integer, Double>();
        unSortedMap.put(1343, 0.521851);
        unSortedMap.put(1950, -0.301208);
        unSortedMap.put(3667, -0.0280762);
        unSortedMap.put(3879, 0.154724);
        unSortedMap.put(4124, 0.022583);

        // Code that calls the ordering method:
        TreeMap<Integer, Double> sortedMap = new TreeMap<Integer, Double>(
                sortTreeMap(unSortedMap));

        // Code that iterates through the "sorted" hashmap.
        System.out.println("now iterate through sortedMap: ");
        for (Integer key : sortedMap.keySet()) {
            System.out.println("key, sortedMap.get(key) are:  " + key + ", "
                    + sortedMap.get(key));
        }
    }

    // Code for the ordering method. Note that the println tests indicate that
    // this method is correctly sorting the key/value pairs in the hashmap:
    private static TreeMap<Integer, Double> sortTreeMap(
            TreeMap<Integer, Double> input) {

        System.out
                .println("input.size() upon entering sortHasMap() function is: "
                        + input.size());
        int startSize = input.size();

        // create a hashmap to store sorted output
        TreeMap<Integer, Double> sortedMap = new TreeMap<Integer, Double>();

        // repeat the following process once for every key/value pair in the
        // hashmap
        for (int i = 0; i < startSize; i++) {
            int mySize = input.size();
            System.out.println("mySize is: " + mySize);
            double maxVal = Double.NEGATIVE_INFINITY;
            int maxKey = 0;

            // iterate through each key in hashmap to find key/value of max
            // value
            for (Integer key : input.keySet()) {
                if (maxVal < input.get(key)) {
                    maxVal = input.get(key);
                    maxKey = key;
                }
            }

            // add key/value of max of that iteration to sorted map and remove
            // from input before next iteration
            sortedMap.put(maxKey, maxVal);

            input.remove(maxKey);

            System.out.println("sortedMap.put(maxKey, maxVal) are: " + maxKey
                    + ", " + maxVal);
        }
        return sortedMap;
    }
}

Answer 1

你只需要兩條線來實現你想要的。 以下是這兩行：

    Map<Integer, Double> sortedMap = new TreeMap<Integer, Double>(new Comparator<Integer>() {
        public int compare(Integer o1, Integer o2) {
            return map.get(o2).compareTo(map.get(o1)); // reverse order of values
        }
    });
    sortedMap.putAll(map);

這是完整的可運行代碼：

public static void main(String[] args) {
    final Map<Integer, Double> map = new HashMap<Integer, Double>();
    map.put(1343, 0.521851);
    map.put(1950, -0.301208);
    map.put(3667, -0.0280762);
    map.put(3879, 0.154724);
    map.put(4124, 0.022583);
    Map<Integer, Double> sortedMap = sortMap(map);

    for (Map.Entry<Integer, Double> entry : sortedMap.entrySet()) {
        System.out.println(entry.getKey() + ", " + entry.getValue());
    }
}

public static Map<Integer, Double> sortMap(final Map<Integer, Double> map) {
    Map<Integer, Double> sortedMap = new TreeMap<Integer, Double>(new Comparator<Integer>() {
        public int compare(Integer o1, Integer o2) {
            return map.get(o2).compareTo(map.get(o1));
        }
    });
    sortedMap.putAll(map);
    return sortedMap;
}

輸出：

1343, 0.521851
3879, 0.154724
4124, 0.022583
3667, -0.0280762
1950, -0.301208

注意：您可以指定要通過傳遞您要使用到構造的比較在一個TreeSet排序項。 TreeSet實現完成剩下的工作。

其他說明：

• 迭代地圖的鍵/值的最佳方法是迭代Map.entrySet()
• 總是使用抽象類型作為變量 - 例如Map<?, ?> myMap 而不是具體的實現（即HashMap<?, ?> myMap ）

這是sortMap方法的通用版本，它將根據值的相反順序對任何合適的映射進行排序：

public static <K, V extends Comparable<V>> Map<K, V> sortMap2(final Map<K, V> map) {
    Map<K, V> sortedMap = new TreeMap<K, V>(new Comparator<K>() {
        public int compare(K o1, K o2) {
            return map.get(o2).compareTo(map.get(o1));
        }
    });
    sortedMap.putAll(map);
    return sortedMap;
}

Answer 2

使用TreeMap 。 它是一個使用鍵的自然排序的SortedMap 。 在您的情況下，它將按Integer鍵排序。

它為您排序。

java.util.HashMap是無序的。

這個類不保證地圖的順序; 特別是，它不保證訂單會隨着時間的推移保持不變。

EDIT 正確閱讀問題后

將比較器用於比較值的TreeMap構造函數。