• java 各种集合排序锦集


    1.在JSONObject中保留LinkedHashMap(存储的是插入的顺序)排序?

    Map<String, String> stateMap = new LinkedHashMap<String, String>();
    JSONObject json = new JSONObject();
    /*
    //这样存储时,没有LinkedHashMap的顺序
    json.putAll(stateMap);
    */
    
    //这样存储时,会有LinkedHashMap的顺序
    与JSONObject不同,JSONArray是一个有序的值序列.
    因此,如果要保留地图的顺序,可以使用两个键构造json对象:
    >第一个键可以称为数据,并将保存您的stateMap数据,如下所示:
    
    json.element('data', stateMap)
    >第二个键可以被称为键,它将是一个JSONArray对象,它将保存地图键的有序列表,如下所示:
    
    JSONArray array = new JSONArray();
    array.addAll(stateMap.keySet())
    json.put('keys', array)
    View Code


    2.LinkedHashMap排序

    LinkedHashMap<String, Float> map = new LinkedHashMap<>();
    
    //先转成ArrayList集合
    ArrayList<Entry<String, Float>> list = 
            new ArrayList<Map.Entry<String, Float>>(map.entrySet());
    
    //从小到大排序(从大到小将o1与o2交换即可)
    Collections.sort(list, new Comparator<Map.Entry<String, Float>>() {
    
        @Override
        public int compare(Entry<String, Float> o1, Entry<String, Float> o2) {
            return ((o1.getValue() - o2.getValue() == 0) ? 
                    0: (o1.getValue() - o2.getValue() > 0) ? 1: -1);
        }
    
    });
    
    //新建一个LinkedHashMap,把排序后的List放入
    LinkedHashMap<String, Float> map2 = new LinkedHashMap<>();
    for (Map.Entry<String, Float> entry : list) {
        map2.put(entry.getKey(), entry.getValue());
    }
    
    //遍历输出
    for (Map.Entry<String, Float> entry : map2.entrySet()) {
        System.out.println(entry.getKey() + ":" + entry.getValue());
    }
    View Code

    3.map排序,map转json防止顺序错乱   

    public static void main(String[] args) {
             Map<String, String> mapsort = new TreeMap<String, String>(
                        new Comparator<String>() {
                            public int compare(String obj1, String obj2) {
                                // 降序排序
                                return obj2.compareTo(obj1);
                            }
                        });
             Map<String,String> map = new HashMap<String, String>();
             map.put("2018-04", "123");
             map.put("2018-01", "123");
             map.put("2018-05", "123");
             map.put("2018-02", "123");
             map.put("2018-06", "123");
             mapsort.putAll(map);
             for (String key : mapsort.keySet()) { 
                  System.out.println("Key = " + key); 
                } 
        }
    
    
    //map转json
    mapsort=JSON.parseObject(mapsort.toString(),new TypeReference<TreeMap<String, String>>(){} ,Feature.OrderedField);
    View Code

    4.JsonObject数据排序(顺序)问题  

    JsonObject内部是用Hashmap来存储的,所以输出是按key的排序来的,如果要让JsonObject按固定顺序(put的顺序)排列,可以修改JsonObject的定义HashMap改为LinkedHashMap。

    public JSONObject() {  
            this.map = new LinkedHashMap();  //new HashMap();  
    }  

    即定义JsonObject可以这样:JSONObject jsonObj = new JSONObject(new LinkedHashMap());

     5.map排序

    5map排序(顺序、倒序)

    package com.actionsoft.apps.ram.test;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    public class javaTest {
        public static void main(String[] args) {
            Map<String, Integer> map = new HashMap<String, Integer>();
            map.put("d", 4);
            map.put("a", 1);
            map.put("c", 3);
            map.put("e", 5);
            map.put("b", 2);
            //排序前
            System.out.println("before sort");
            for (Map.Entry<String, Integer> entry : map.entrySet()) {
                System.out.println(entry.getKey() + "->" + entry.getValue());
            }
            System.out.println();
            //将map转成list
            List<Map.Entry<String, Integer>> infos = new ArrayList<Map.Entry<String, Integer>>(map.entrySet());
            //对list排序,实现新的比较器
            Collections.sort(infos, new Comparator<Map.Entry<String, Integer>>() {
                @Override
                public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
                    return o1.getValue() - o2.getValue();
                }
            });
            //申明新的有序 map,根据放入的数序排序
            Map<String, Integer> lhm = new LinkedHashMap<String, Integer>();
            //遍历比较过后的map,将结果放到LinkedHashMap
            for (Map.Entry<String, Integer> entry : infos) {
                lhm.put(entry.getKey(), entry.getValue());
            }
            //遍历LinkedHashMap,打印值
            System.out.println("after sort");
            for (Map.Entry<String, Integer> entry : lhm.entrySet()) {
                System.out.println(entry.getKey() + "->" + entry.getValue());
            }
        }
    }
  • 相关阅读:
    继承中的虚函数、纯虚函数、普通函数
    struct与class的区别
    boost::filesystem总结
    ASM: Active Shape Models--Their Training and Application
    基础知识:仿射变换、相似变换、等距变换等常见变换
    PDM:Training Models of Shape from Sets of Examples
    常见优化器
    深度学习基础(五)ResNet_Deep Residual Learning for Image Recognition
    深度学习基础(四) Dropout_Improving neural networks by preventing co-adaptation of feature detectors
    ios 各种变量和作用范围
  • 原文地址:https://www.cnblogs.com/renpei/p/12515606.html
Copyright © 2020-2023  润新知