使用map操作对象排序，根据对象字段排序

map是一个由键值对数据组成的集合。在某个项目中，前端显示的数据量不大，于是采用map进行显示。但是后来才发现，这样并不是醉简单的处理方式，但是由于一开始没考虑好，一路坑到底。把对数据库的操作转成在map身上，如果只是用于学习，可以借鉴，如果是要在项目中进行操作的话，可能会偏复杂，特别是分页操作。

现在描述一下我们的需求：

一 ：假设一个对象有三个字段用来存储三个名称，现在要进行排序显示，第三个名词根据第二个名称排序，第二个名称根据第一个名称排序。

     1：从数据取出数据，存放在Map<String, **>中，**是代表对象，我这边用Object代替。key可以根据对象id存储，注意：key不能重复，否则数据会出现缺漏。

现在前端要显示，调用存储的map数据，所以我们需要对数据进行排序

    public static Map<String, Object> getSortMap() {
        Map<String, Object> tempMap = new LinkedHashMap<String, Object>();
        List<Map.Entry<String, Object>> list = new ArrayList<Map.Entry<String, Object>>(map.entrySet());//这里的map是数据库查找出来的数据
        Collections.sort(list,new MyComparator()); //排序操作
        Iterator<Map.Entry<String, Object>> i = list.iterator();
        while (i.hasNext()) {
          Map.Entry<String, Object> entry = i.next();
          tempMap.put(entry.getKey(),entry.getValue());
        }
        return tempMap;
    }

排序类：

public class MyComparatorimplements Comparator<Map.Entry<String, Object>> {

    /**
     * //:根据父级排序，再根据本身的排序值排序
     */
    /*@Override
    public int compare(Entry<String, Object> o1, Entry<String, Object> o2) {
        Object h1=o1.getValue();
        Object h2=o2.getValue();
        if ((h1.getName1().compareTo(h2.getName2()))>0) {//先根据第一个名称排序
            return 1;
        } else     if ((h1.getName1().compareTo(h2.getName1()))==0) {
            if ((h1.getName2().compareTo(h2.getName2()))>0) {//第一个名称相同按第二个名称排序
                return 1;
            }else if ((h1.getName2().compareTo(h2.getName2()))==0) {
                if ((h1.getName3().compareTo(h2.getName3()))==0) {//第二个名称相同按第三个名称排序
                    return 1;
                }else if(Integer.parseInt(h1.getDisplayorder())==Integer.parseInt(h2.getDisplayorder())){
                    return 0;
                }else{
                    return -1;
                }
            }else{
                return 0;
            }
        } else
            return -1;
    }
}

二：现在数据在前端可以显示了，但是呢，点击字段的时候要根据这个字段排序。针对不同框架，前端传过来的数据可能略不同，我这边是传“字段名+空格+排序方式（ASC/DESC）”，比如要根据object的id进行排序，点击的时候会传id desc或者id asc过来。

1：在object穿件一个排序字段order

现在在controller需要这样处理

String orderBy=page.getOrder();//框架封装自动传输的数据
object.order=orderBy;//赋值

2：在相同的getSortMap()进行操作

public static Map<String, Object> getSortMap() {
        Map<String, Object> tempMap = new LinkedHashMap<String, Object>();
        List<Map.Entry<String, Object>> list = new ArrayList<Map.Entry<String, Object>>(map.entrySet());//这里的map是数据库查找出来的数据
       if(StringUtils.isNotEmpty(Object.order)){//字段排序操作返回
              Collections.sort(list,new MyComparator2(getOrder()));//另一个排序接口
        }else{//正常显示的排序返回
            Collections.sort(list,new MyComparator());
        }
        Iterator<Map.Entry<String, Object>> i = list.iterator();
        while (i.hasNext()) {
          Map.Entry<String, Object> entry = i.next();
          tempMap.put(entry.getKey(),entry.getValue());
        }
        return tempMap;
    }

//这边要根据字段排序，我们的思路是通过反射遍历object属性，如果前端传过来的属性名称跟object字段名称一样，则根据这个字段进行排序

public class MyComparator2 implements Comparator<Map.Entry<String, Object>> {
    
    private String orderBy;
    
    public Level2Comparator(String orderBy) {
        this.orderBy=orderBy;
    }
    
    /**
     * 列表排序，根据属性值排序
     */
    @Override
    public int compare(Entry<String, Object> o1, Entry<String, Object> o2) {
        Object h1=o1.getValue();
        Object h2=o2.getValue();
        if(StringUtils.isNotEmpty(orderBy)){

            String[] fileNames=orderBy.split(" ");
            String name=fileNames[0];//属性名称
            String rule=fileNames[1];//规则.升降
            Field[] fs = HkCategory.class.getDeclaredFields();
            for(int i = 0 ; i < fs.length; i++){  
                 Field f = fs[i];
                 f.setAccessible(true); //设置些属性是可以访问的  
                 String fileName=f.getName();//属性名称
                 try {

                     if(name.indexOf(".")>0){//特殊字段处理比如"level1.name"
                         String name2=name.substring(name.indexOf(".")+1,name.length());
                         name=name.substring(0, name.indexOf("."));
                     }
                     if(fileName.equals(name)){
                         if("level1".equals(name)||"level2".equals(name)){
                             LevelCategory level1=null;
                             LevelCategory level2=null;
                             if("level1".equals(name)){
                                 level1=h1.getLevel1();
                                 level2=h2.getLevel1();
                             }
                             if("level2".equals(name)){
                                 level1=h1.getLevel2();
                                 level2=h2.getLevel2();                       
                             }
                             if((level1.getName().compareTo(level2.getName()))>0){
                                 if("ASC".equals(rule)){
                                     return 1;
                                 }else{
                                     return -1;
                                 }
                                }else   if((level1.getName().compareTo(level2.getName()))==0){
                                    return 0;
                                }else{
                                     if("ASC".equals(rule)){
                                         return -1;
                                     }else{
                                         return 1;
                                     }
                                }
                         }
                        
                         String UpFirstOrderBy=name.substring(0, 1).toUpperCase();
                         String UpOrderBy=UpFirstOrderBy+name.substring(1, name.length());
                         Method m2 = HkCategory.class.getMethod("get"+UpOrderBy);//调用get方法
                         Object obj1=m2.invoke(h1);//获取属属性值
                         Object obj2=m2.invoke(h2);;//获取属属性值
                         String fileType = f.getType().getSimpleName().toLowerCase();//得到此属性的类型
                         if("integer".equals(fileType)){//srtring,date,integer不同的数据类型，排序操作不一样
                             Integer a1=(Integer) obj1;
                             Integer a2=(Integer) obj2;
                             if(a1>a2){
                                 if("ASC".equals(rule)){
                                     return 1;
                                 }else{
                                     return -1;
                                 }    
                                 }else  if(a1==a2){
                                    return 0;
                                }else{
                                     if("ASC".equals(rule)){
                                         return -1;
                                     }else{
                                         return 1;
                                     }
                                }
                            }
                         if("date".equals(fileType)){
                                Date date1=(Date) obj1;
                                Date date2=(Date) obj2;
                                if(date1.getTime()<date2.getTime()){
                                 if("ASC".equals(rule)){
                                     return 1;
                                 }else{
                                     return -1;
                                 }
                                }else  if(date1.getTime()==date2.getTime()){
                                    return 0;
                                }else{
                                     if("ASC".equals(rule)){
                                         return -1;
                                     }else{
                                         return 1;
                                     }
                                }
                            }
                         if("string".equals(fileType)){
                             if("displayorder".equals(fileName)){//数值排序
                                 Integer a1=Integer.parseInt(obj1.toString());
                                 Integer a2=Integer.parseInt(obj2.toString());
                                 if(a1>a2){
                                     if("ASC".equals(rule)){
                                         return 1;
                                     }else{
                                         return -1;
                                     }    
                                     }else  if(a1==a2){
                                        return 0;
                                    }else{
                                         if("ASC".equals(rule)){
                                             return -1;
                                         }else{
                                             return 1;
                                         }
                                    }
                             }else{
                             if((obj1.toString().compareTo(obj2.toString()))>0){
                                 if("ASC".equals(rule)){
                                     return 1;
                                 }else{
                                     return -1;
                                 }
                                }else  if((obj1.toString().compareTo(obj2.toString()))==0){
                                    return 0;
                                }else{
                                     if("ASC".equals(rule)){
                                         return -1;
                                     }else{
                                         return 1;
                                     }
                                }
                            }
                         }
                     }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
        return 0;
    }
}

综上：已经完成map的数据显示，排序操作。如果还有进行分页，那会继续麻烦下去，如果是使用数据操作的话，排序可能只要一条sql，所以这个坑就到此为止吧。。。。

希望对你学习map有所帮助。