如何在包含具有多个键/值对的 HashMap 的列表上使用 indexOf

Question

我有一个包含 HashMaps 的 List。列表中的每个HashMap 可能有多个键/值 对。我想在列表上 indexOf 找出传入 HashMap 的元素的索引。但是，问题是 e 在比较时会查看整个entrySet。这不是我想要的。

示例：

    List<HashMap> benefit = new ArrayList<HashMap>();
    HashMap map1 = new HashMap();
    map1.put("number", "1");
    benefit.add(map1);
    HashMap map2 = new HashMap();
    map2.put("number", "2");
    map2.put("somethingelse", "blahblah"); //1
    benefit.add(map2);

    HashMap find = new HashMap();
    find.put("number", "2");
    int index = benefit.indexOf(find);
    if (index >= 0)
        System.out.println(benefit.get(index).get("number"));

上面的代码由于带有 //1 行而没有打印任何内容。

• 我需要做什么才能使上面的代码实际打印 2 ？
• 有没有办法在列表上实现可比较，以便我可以定义 我自己的？

Answer 1

我认为您正在寻找 retainAll()，因此您可以仅比较您感兴趣的元素：

int index = myIndexOf(benefit, find);

...

static int myIndexOf(List<HashMap> benefit, Map find) {
    int i = 0;
    for (Map map : benefit) {
        Map tmp = new HashMap(map);
        tmp.keySet().retainAll(find.keySet());
        if (tmp.equals(find)) {
            return i;
        }
        i++;
    }
    return -1;
}

当然，可以声明您自己的 List 子类，该子类重写了 indexOf 方法这种行为。但是，我认为这不是一个好主意。它会违反 indexOf 方法的约定：

返回满足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i

这会让维护代码的其他人感到困惑。然后您可能会认为可以子类化 HashMap 来重新定义 equals，但这会违反 Object.equals() 的对称属性。

Answer 2

你试图实现目标的方式是错误的。 indexOf 方法的工作方式与本例中应有的方式完全相同。它试图找到完全匹配，而不是部分匹配。

如果我理解正确的话，您要做的就是在地图列表中找到包含特定条目的地图。在这种情况下，您应该手动执行此搜索，方法是遍历所有映射，调用 containsKey ()，然后将您期望找到的值与与该键关联的值进行比较。

另一种方法是围绕您的 List 创建一个代理类，并添加一个新方法 findMapWithEntry (String key, String value)，它将为您执行此搜索（与我上面描述的搜索相同）。

Answer 3

为什么不改变你的搜索方式呢？

List<Map> matchingBenefits = new ArrayList<Map>();
for (Map m : benefit) {
    if (m.containsKey("number") && m.get("number").equals("2"))
        matchingBenefits.add(m);
}
for (Map m : matchingBenefits) {
    System.out.println(m.get("number"));
}

Answer 4

您始终可以重写indexOf方法。查看 ArrayList 的源代码：

   public int indexOf(Object o) {
     if (o == null) {
       for (int i = 0; i < size; i++)
         if (elementData[i]==null)
          return i;
     else {
       for (int i = 0; i < size; i++)
         if (o.equals(elementData[i]))
           return i;
     }
     return -1;
   }

所以它根本不是一个非常复杂的搜索算法。您可能会看到这样的内容：

List benefit = new ArrayList(){
 public int indexOf(Object o){
      if (o == null) {
        for (int i = 0; i < size; i++)
         if (elementData[i]==null)
           return i;
      else {
        for (int i = 0; i < size; i++) //traverse the hashmaps
         Object key = ((HashMap)o).keySet().get(0); //assuming one pair
         Object val = ((HashMap)o).valueSet().get(0);
         if (
            ((HashMap)elementData[i]).containsKey(key) &&             
            ((HashMap)elementData[i]).get(key).equals(val))
              return i;
      }
      return -1;
 };

我的建议是考虑一种不同的数据结构，也许可以为其编写自己的数据结构。

Answer 5

鉴于您无法更改设计，编写自己的 find 方法会有帮助吗？

如果我理解你想要做什么并且它在 O(n) 中运行，下面的代码应该可以工作

public static String find(List<HashMap<String,String>> listMap, String key, String value) {
    for(int i = 0; i < listMap.size(); i++)
        if(listMap.get(i).get(key).equals(value))
            return value;

    return null;
}