Java 如何按升序和降序对hashmap数据进行排序

我有一个

HashMap

myData

我希望能够按升序对我的

HashMap

进行排序，然后将其放入一个变量中，我将使用该变量迭代并添加到excel文件中。我还想按降序排序，然后在变量中得到结果，迭代它并将数据添加到excel文件中。我的HashMap看起来是这样的：

Aug-19，{“11”，“12”}July-19，{“01”，“22”}Jun-19，{“77”，“02”}May-19，{“99”，“42”}

关键是日期。这个值只是一个字符串列表。我需要检索包含按升序排序的数据的变量，在另一个变量中检索按降序排序的数据。非常感谢您的帮助。

首先将地图中的键转换为更自然的格式，即日期。然后将它们存储在TreeMap中，TreeMap是一个按排序顺序存储键的关联容器

使用

parse（String）

获取

Date

对象，然后使用

format（Date）

重新获得该对象的字符串形式

public class DateAsTreeMapKey {
    public static void main(String[] args) {
        HashMap<String, List<String>> myData = new HashMap<>();

        String format = "MMM - yy";
        myData.put("Aug - 19", Arrays.asList("11", "12"));
        myData.put("July - 19", Arrays.asList("01", "22")); // try out July also
        myData.put("Jun - 19", Arrays.asList("77", "02"));
        myData.put("May - 19", Arrays.asList("99", "42"));      
        printDataInAscendingOrder(getDataInSortedForm(myData, format), format);
        printDataInDescendingOrder(getDataInSortedForm(myData, format), format);

    }
    public static TreeMap<Date, List<String>> getDataInSortedForm(HashMap<String, List<String>> myData, String format) {
        TreeMap<Date, List<String>> mySortedData = new TreeMap<>();
        for (Map.Entry<String, List<String>> entry : myData.entrySet()) {
            String monthYear = entry.getKey();
            List<String> data = entry.getValue();
            try {
                Date date = new SimpleDateFormat(format, Locale.ENGLISH).parse(monthYear);
                mySortedData.put(date, data);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return mySortedData;
    }
    public static void printDataInAscendingOrder(TreeMap<Date, List<String>> mySortedData, String format) {
        System.out.println("Data in ascending order: ");
        for (Entry<Date, List<String>> entry : mySortedData.entrySet()) {
            System.out.println("Month '" + new SimpleDateFormat(format, Locale.ENGLISH).format(entry.getKey())
                    + "' has data as " + entry.getValue().toString());
        }
    }
    public static void printDataInDescendingOrder(TreeMap<Date, List<String>> mySortedData, String format) {
        System.out.println("Data in descending order: ");
        TreeMap<Date, List<String>> mySortedDataReversed = new TreeMap<>(Collections.reverseOrder());
        mySortedDataReversed.putAll(mySortedData);
        for (Entry<Date, List<String>> entry : mySortedDataReversed.entrySet()) {
            System.out.println("Month '" + new SimpleDateFormat(format, Locale.ENGLISH).format(entry.getKey())
                    + "' has data as " + entry.getValue().toString());
        }
    }
}

---

这是一个Java1.8+流版本。它可以更有效，但这可能会混淆示例，所以我将此留给您。请注意，排序和反转顺序之间的唯一区别是.reversed（）方法

import org.junit.jupiter.api.Test；
导入java.text.ParseException；
导入java.text.simpleDataFormat；
导入java.util.array；
导入java.util.Comparator；
导入java.util.HashMap；
导入java.util.List；
导入java.util.Map；
公共类地图分拣机{
@试验
公开无效测试（）{
Map myData=newhashmap（）；
myData.put（“8月19日”，Arrays.asList（“11”、“12”）；
myData.put（“July-19”，Arrays.asList（“01”，“22”）；//也可以试用July
myData.put（“Jun-19”，Arrays.asList（“77”，“02”）；
myData.put（“5-19”，Arrays.asList（“99”，“42”）；
myData.keySet（）.stream（）
.map（可排序键：：新建）
.sorted（Comparator.comparingLong（SortableKey:：getSortableKey））
.map（SortableKey:：getOriginalKey）
.forEach（originalKey->addToExcel（originalKey，myData））；
myData.keySet（）.stream（）
.map（可排序键：：新建）
.sorted（Comparator.comparingLong（SortableKey:：getSortableKey）
.reversed（））
.map（SortableKey:：getOriginalKey）
.forEach（originalKey->addToExcel（originalKey，myData））；
}
私有void addToExcel（字符串键、映射）{
System.out.println（key+“=”+map.get（key））；
}
类可排序键{
私有字符串dateStr；
私有长可排序密钥；
SortableKey（字符串dateStr）{
this.dateStr=dateStr；
试一试{
sortableKey=newsimpledateformat（“MMM-yy”）.parse（dateStr.getTime（）；
}捕获（解析异常）{
//某种类型的错误处理
}
}
长getSortableKey（）{
返回可排序键；
}
字符串getOriginalKey（）{
返回日期str；
}
}
}

可以使用

树形图

而不是

哈希图

。您无法对

HashMap

进行排序（至少，没有一些严重的黑魔法是不行的）。上面的示例的输出是什么？我想您希望根据“MMM-yy”形式的键进行排序。是这样吗？

Data in ascending order: 
Month 'May - 19' has data as [99, 42]
Month 'Jun - 19' has data as [77, 02]
Month 'Jul - 19' has data as [01, 22]
Month 'Aug - 19' has data as [11, 12]
Data in descending order: 
Month 'Aug - 19' has data as [11, 12]
Month 'Jul - 19' has data as [01, 22]
Month 'Jun - 19' has data as [77, 02]
Month 'May - 19' has data as [99, 42]

import org.junit.jupiter.api.Test;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MapSorter {

    @Test
    public void test() {

        Map<String, List<String>> myData = new HashMap<>();

        myData.put("Aug - 19", Arrays.asList("11", "12"));
        myData.put("July - 19", Arrays.asList("01", "22")); // try out July also
        myData.put("Jun - 19", Arrays.asList("77", "02"));
        myData.put("May - 19", Arrays.asList("99", "42"));

        myData.keySet().stream()
          .map(SortableKey::new)
          .sorted(Comparator.comparingLong(SortableKey::getSortableKey))
          .map(SortableKey::getOriginalKey)
          .forEach(originalKey -> addToExcel(originalKey, myData));
        myData.keySet().stream()
          .map(SortableKey::new)
          .sorted(Comparator.comparingLong(SortableKey::getSortableKey)
                    .reversed())
          .map(SortableKey::getOriginalKey)
          .forEach(originalKey -> addToExcel(originalKey, myData));
    }

    private void addToExcel(String key, Map<String, List<String>> map) {
        System.out.println(key + " = " + map.get(key));
    }

    class SortableKey {

        private String dateStr;
        private long sortableKey;

        SortableKey(String dateStr) {
            this.dateStr = dateStr;
            try {
                sortableKey = new SimpleDateFormat("MMM - yy").parse(dateStr).getTime();
            } catch (ParseException e) {
                // some type of error handling
            }
        }

        long getSortableKey() {
            return sortableKey;
        }

        String getOriginalKey() {
            return dateStr;
        }
    }
}