Java 基于hashMap值[非键]对hashMap列表进行排序

这是我所拥有的-

如何比较多个键及其值？现在我只使用employeeId，但我想在排序比较中包括departmentId和other

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

public class Tester {

    boolean flag = false ;


    public static void main(String args[]) {
        Tester tester = new Tester() ;
        tester.printValues() ;
    }

    public void printValues ()
    {

        List<HashMap<String,Object>> list = new ArrayList<HashMap<String,Object>>() ;
        HashMap<String,Object> map = new HashMap<String,Object>();


        map = new HashMap<String,Object>();
        map.put("employeeId", new Integer(1234)) ;
        map.put("departmentId", new Integer(110)) ;
        map.put("someFlag", "B") ;
        map.put("eventTypeId", new Integer(11)) ;
        map.put("startDate", new Date() ) ;
        map.put("endDate", new Date() ) ;
        list.add(map);


        map = new HashMap<String,Object>();
        map.put("employeeId", new Integer(456)) ;
        map.put("departmentId", new Integer(100)) ;
        map.put("someFlag", "B") ;
        map.put("eventTypeId", new Integer(11)) ;
        map.put("startDate", new Date() ) ;
        map.put("endDate", new Date() ) ;
        list.add(map);


        map = new HashMap<String,Object>();
        map.put("employeeId", new Integer(1234)) ;
        map.put("departmentId", new Integer(10)) ;
        map.put("someFlag", "B") ;
        map.put("eventTypeId", new Integer(17)) ;
        map.put("startDate", new Date() ) ;
        map.put("endDate", new Date() ) ;
        list.add(map);

        map = new HashMap<String,Object>();
        map.put("employeeId", new Integer(1234)) ;
        map.put("departmentId", new Integer(99)) ;
        map.put("someFlag", "B") ;
        map.put("eventTypeId", new Integer(11)) ;
        map.put("startDate", new Date() ) ;
        map.put("endDate", new Date() ) ;
        list.add(map);

        map = new HashMap<String,Object>();
        map.put("employeeId", new Integer(1234)) ;
        map.put("departmentId", new Integer(100)) ;
        map.put("someFlag", "B") ;
        map.put("eventTypeId", new Integer(11)) ;
        map.put("startDate", new Date() ) ;
        map.put("endDate", new Date() ) ;
        list.add(map);



        map = new HashMap<String,Object>();
        map.put("employeeId", new Integer(567)) ;
        map.put("departmentId", new Integer(200)) ;
        map.put("someFlag", "P") ;
        map.put("eventTypeId", new Integer(12)) ;
        map.put("startDate", new Date()  ) ;
        map.put("endDate", new Date() ) ;
        list.add(map);

        Collections.sort ( list , new HashMapComparator2 () ) ;

        for( int i = 0 ; i < list.size() ; i ++ ) {
            System.out.println(list.get(i));    
        }

        System.out.println("======================================");    


        flag = true ; // desc
        Collections.sort ( list , new HashMapComparator2 () ) ;

        for( int i = 0 ; i < list.size() ; i ++ ) {
            System.out.println(list.get(i));    
        }

    }

    public class HashMapComparator2 implements Comparator
    {
        public int compare ( Object object1 , Object object2 )
        {
            if ( flag == false )
            {


                Integer obj1Value = ( Integer ) ( ( HashMap ) object1 ).get ( "employeeId" ) ;
                Integer obj2Value = ( Integer ) ( ( HashMap ) object2 ).get ( "employeeId" ) ;

                return obj1Value.compareTo ( obj2Value ) ;
            }
            else
            {
                Integer obj1Value = ( Integer ) ( ( HashMap ) object1 ).get ( "employeeId" ) ;
                Integer obj2Value = ( Integer ) ( ( HashMap ) object2 ).get ( "employeeId" ) ;

                return obj2Value.compareTo ( obj1Value ) ;
            }
        }
    }


}

import java.util.ArrayList；
导入java.util.Collections；
导入java.util.Comparator；
导入java.util.Date；
导入java.util.HashMap；
导入java.util.List；
公共类测试员{
布尔标志=假；
公共静态void main（字符串参数[]）{
测试仪=新测试仪（）；
tester.printValues（）；
}
公共无效打印值（）
{
列表=新的ArrayList（）；
HashMap=newHashMap（）；
map=新的HashMap（）；
map.put（“employeeId”，新整数（1234））；
map.put（“departmentId”，新整数（110））；
地图放置（“someFlag”、“B”）；
put（“eventTypeId”，新的整数（11））；
map.put（“开始日期”，新日期（））；
map.put（“endDate”，newdate（））；
列表。添加（地图）；
map=新的HashMap（）；
map.put（“employeeId”，新整数（456））；
map.put（“部门ID”，新整数（100））；
地图放置（“someFlag”、“B”）；
put（“eventTypeId”，新的整数（11））；
map.put（“开始日期”，新日期（））；
map.put（“endDate”，newdate（））；
列表。添加（地图）；
map=新的HashMap（）；
map.put（“employeeId”，新整数（1234））；
map.put（“departmentId”，新整数（10））；
地图放置（“someFlag”、“B”）；
put（“eventTypeId”，新的整数（17））；
map.put（“开始日期”，新日期（））；
map.put（“endDate”，newdate（））；
列表。添加（地图）；
map=新的HashMap（）；
map.put（“employeeId”，新整数（1234））；
map.put（“departmentId”，新整数（99））；
地图放置（“someFlag”、“B”）；
put（“eventTypeId”，新的整数（11））；
map.put（“开始日期”，新日期（））；
map.put（“endDate”，newdate（））；
列表。添加（地图）；
map=新的HashMap（）；
map.put（“employeeId”，新整数（1234））；
map.put（“部门ID”，新整数（100））；
地图放置（“someFlag”、“B”）；
put（“eventTypeId”，新的整数（11））；
map.put（“开始日期”，新日期（））；
map.put（“endDate”，newdate（））；
列表。添加（地图）；
map=新的HashMap（）；
map.put（“employeeId”，新整数（567））；
map.put（“departmentId”，新整数（200））；
地图放置（“someFlag”、“P”）；
put（“eventTypeId”，新的整数（12））；
map.put（“开始日期”，新日期（））；
map.put（“endDate”，newdate（））；
列表。添加（地图）；
Collections.sort（list，新的HashMapComparator2（））；
对于（int i=0；i

首先，我将创建一个类来存储数据，而不是使用哈希映射列表。然后使该类实现可比较接口，该接口允许您确定细粒度比较算法

如果您确实需要使用HashMap，那么我将创建一个扩展HashMap并实现Comparable的类。但我不推荐这种方法

public class Foo extends HashMap implements Comparable {
  private boolean ascending = true;

  public int compareTo(Object bar) {
    int result;
    if (bar == null || !(bar instanceof Foo)) {
      result = -1;
    }
    Foo _rhs = (Foo)bar;
    result = new CompareToBuilder().append(get("employeeId"),_rhs.get("employeeId"))
                 .append(get("departmentId"),_rhs.get("departmentId")).toComparison();

    return (ascending ? result : -result);
  }

  public void setAscending(boolean asc) {
    ascending = asc;
  }
}

---

不保证此代码将编译或返回正确的结果。我真的很喜欢CompareToBuilder，martinatime的答案是正确的。创建一个类来存储数据。然后将其放入支持键排序的映射中，例如TreeMap：

new TreeMap<Integer, YouNewClass>(new Comparator<YourNewClass>() {

 public int compare(YourNewClass o1, YourNewClass o2) {
       implement the method here as per your logic.
 }

});

newtreemap（newcomparator（）{
公共整数比较（YourNewClass o1，YourNewClass o2）{
根据您的逻辑在此处实现该方法。
}
});

享受： 最简单的方法是使用from。 您的示例如下所示：

Map<String, Object> map1 = (Map<String, Object>) object1;
Map<String, Object> map2 = (Map<String, Object>) object2;
if ( flag == false ) {
    return new CompareToBuilder()
        .append(map1.get("employeeId"), map2.get("employeeId"))
        .append(map1.get("departmentId"), map2.get("departmentId"))
        .toComparison();
}
else {
    return new CompareToBuilder()
        .append(map2.get("employeeId"), map1.get("employeeId"))
        .append(map2.get("departmentId"), map1.get("departmentId"))
        .toComparison();
}

map1=（Map）object1；
MapMap2=（Map）object2；
如果（标志==false）{
返回新的CompareToBuilder（）
.append（map1.get（“employeeId”）、map2.get（“employeeId”））
.append（map1.get（“部门ID”）、map2.get（“部门ID”））
.toComparison（）；
}
否则{
返回新的CompareToBuilder（）
.append（map2.get（“employeeId”）、map1.get（“employeeId”））
.append（map2.get（“部门ID”）、map1.get（“部门ID”））
.toComparison（）；
}

---

或者类似的。无论如何，我绝对建议您在比较器中使用Genrics，正如Danil所建议的那样。

第二种方法有没有代码片段？我想在我的情况下使用列表是不可避免的。如果有人能更新我上面的例子，我会很有帮助。我是一个老派的Java开发人员，在使用泛型方面毫无经验，但我会在我的答案中用非泛型代码给出一个例子，你可以根据自己的使用来调整它。哦..很抱歉我错过了你之前的评论！我会试试你的方法！请注意，我不知道人们为什么痴迷于泛型。它使代码易于阅读，尤其是在这种情况下。如果没有泛型，那么只需进行铸造即可实现完全相同的效果。让我们知道你的最终解决方案