如何根据值来比较两个地图

Posted

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了如何根据值来比较两个地图相关的知识,希望对你有一定的参考价值。

如何按价值比较两张地图?我有两个包含相等值的地图,并希望通过它们的值进行比较。这是一个例子:

    Map a = new HashMap();
    a.put("foo", "bar"+"bar");
    a.put("zoo", "bar"+"bar");

    Map b = new HashMap();
    b.put(new String("foo"), "bar"+"bar");
    b.put(new String("zoo"), "bar"+"bar");

    System.out.println("equals: " + a.equals(b));            // obviously false

    .... what to call to obtain a true?

[[编辑:有人请编辑并修复此问题,以表示其实际意味着什么。上面的代码打印“true”,而不是“false”。 ]]

显然,要实现比较并不困难,只需比较所有键及其相关值即可。我不相信我是第一个这样做的人,所以必须已经有一个库函数在java或jakarta.commons库中。

谢谢

答案

您尝试使用串联构造不同的字符串将失败,因为它是在编译时执行的。这两张地图都有一对;每对都将使用“foo”和“barbar”作为键/值,两者都使用相同的字符串引用。

假设您确实想要比较值集而不引用任何键,那么它只是一个例子:

Set<String> values1 = new HashSet<>(map1.values());
Set<String> values2 = new HashSet<>(map2.values());
boolean equal = values1.equals(values2);

map1.values()map2.values()进行比较是可行的 - 但是它们返回的顺序也可能用于相等比较,这不是你想要的。

请注意,使用集合有其自身的问题 - 因为上面的代码会认为{“a”:“0”,“b”:“0”}和{“c”:“0”}的映射相等。毕竟,价值集是相等的。

如果你能对你想要的东西提供更严格的定义,那么确保我们给你正确答案会更容易。

另一答案

@paweloque为了比较java中的两个地图对象,您可以将地图的键添加到列表中,使用这两个列表,您可以使用方法retainAll()和removeAll(),并将它们添加到另一个公共键列表和不同的键列表中。使用公共列表和不同列表的键,您可以迭代地图,使用等于您可以比较地图。

下面的代码将给出如下输出:在{zoo = barbar,foo = barbar}之后{zoo = barbar,foo = barbar}等于:之前 - barbar后 - barbar Equal:before- barbar after-barbar

package com.demo.compareExample

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.collections.CollectionUtils;

public class Demo 
{
    public static void main(String[] args) 
    {
        Map<String, String> beforeMap = new HashMap<String, String>();
        beforeMap.put("foo", "bar"+"bar");
        beforeMap.put("zoo", "bar"+"bar");

        Map<String, String> afterMap = new HashMap<String, String>();
        afterMap.put(new String("foo"), "bar"+"bar");
        afterMap.put(new String("zoo"), "bar"+"bar");

        System.out.println("Before "+beforeMap);
        System.out.println("After "+afterMap);

        List<String> beforeList = getAllKeys(beforeMap);

        List<String> afterList = getAllKeys(afterMap);

        List<String> commonList1 = beforeList;
        List<String> commonList2 = afterList;
        List<String> diffList1 = getAllKeys(beforeMap);
        List<String> diffList2 = getAllKeys(afterMap);

        commonList1.retainAll(afterList);
        commonList2.retainAll(beforeList);

        diffList1.removeAll(commonList1);
        diffList2.removeAll(commonList2);

        if(commonList1!=null & commonList2!=null) // athough both the size are same
        {
            for (int i = 0; i < commonList1.size(); i++) 
            {
                if ((beforeMap.get(commonList1.get(i))).equals(afterMap.get(commonList1.get(i)))) 
                {
                    System.out.println("Equal: Before- "+ beforeMap.get(commonList1.get(i))+" After- "+afterMap.get(commonList1.get(i)));
                }
                else
                {
                    System.out.println("Unequal: Before- "+ beforeMap.get(commonList1.get(i))+" After- "+afterMap.get(commonList1.get(i)));
                }
            }
        }
        if (CollectionUtils.isNotEmpty(diffList1)) 
        {
            for (int i = 0; i < diffList1.size(); i++) 
            {
                System.out.println("Values present only in before map: "+beforeMap.get(diffList1.get(i)));
            }
        }
        if (CollectionUtils.isNotEmpty(diffList2)) 
        {
            for (int i = 0; i < diffList2.size(); i++) 
            {
                System.out.println("Values present only in after map: "+afterMap.get(diffList2.get(i)));
            }
        }
    }

    /**getAllKeys API adds the keys of the map to a list */
    private static List<String> getAllKeys(Map<String, String> map1)
    {
        List<String> key = new ArrayList<String>();
        if (map1 != null) 
        {
            Iterator<String> mapIterator = map1.keySet().iterator();
            while (mapIterator.hasNext()) 
            {
                key.add(mapIterator.next());
            }
        }
        return key;
    }
}

另一答案
public boolean equalMaps(Map<?, ?> map1, Map<?, ?>map2) {

    if (map1==null || map2==null || map1.size() != map2.size()) {
        return false;
    }

    for (Object key: map1.keySet()) {
        if (!map1.get(key).equals(map2.get(key))) {
            return false;
        }
    }
    return true;
}
另一答案

如果您想比较两个地图,那么下面的代码可能会对您有所帮助

(new TreeMap<String, Object>(map1).toString().hashCode()) == new TreeMap<String, Object>(map2).toString().hashCode()
另一答案

比较地图的价值平等的正确方法是:

  1. 检查地图是否大小相同(!)
  2. 从一张地图中获取一组键
  3. 对于您检索到的那组中的每个键,检查从该键的每个映射中检索的值是否相同(如果一个映射中缺少该键,则表示完全失败的相等)

换句话说(减去错误处理):

boolean equalMaps(Map<K,V>m1, Map<K,V>m2) {
   if (m1.size() != m2.size())
      return false;
   for (K key: m1.keySet())
      if (!m1.get(key).equals(m2.get(key)))
         return false;
   return true;
}
另一答案

要查看两个地图是否具有相同的值,您可以执行以下操作:

  • 获取他们的Collection<V> values()视图
  • 换入List<V>
  • Collections.sort那些名单
  • 测试两个列表是否是equals

像这样的东西工作(虽然它的类型边界可以改进):

static <V extends Comparable<V>>
boolean valuesEquals(Map<?,V> map1, Map<?,V> map2) {
    List<V> values1 = new ArrayList<V>(map1.values());
    List<V> values2 = new ArrayList<V>(map2.values());
    Collections.sort(values1);
    Collections.sort(values2);
    return values1.equals(values2);
}

测试工具:

Map<String, String> map1 = new HashMap<String,String>();
map1.put("A", "B");
map1.put("C", "D");

Map<String, String> map2 = new HashMap<String,String>();
map2.put("A", "D");
map2.put("C", "B");

System.out.println(valuesEquals(map1, map2)); // prints "true"

由于O(N log N),这是Collections.sort

See also:


测试键是否等于更容易,因为它们是Set<K>

map1.keySet().equals(map2.keySet())

See also:

另一答案

所有这些都是平等的。它们实际上并没有进行比较,这对排序很有用。这将更像是一个比较器:

private static final Comparator stringFallbackComparator = new Comparator() {
    public int compare(Object o1, Object o2) {
        if (!(o1 instanceof Comparable))
            o1 = o1.toString();
        if (!(o2 instanceof Comparable))
            o2 = o2.toString();
        return ((Comparable)o1).compareTo(o2);
    }
};

public int compare(Map m1, Map m2) {
    TreeSet s1 = new TreeSet(stringFallbackComparator); s1.addAll(m1.keySet());
    TreeSet s2 = new TreeSet(stringFallbackComparator); s2.addAll(m2.keySet());
    Iterator i1 = s1.iterator();
    Iterator i2 = s2.iterator();
    int i;
    while (i1.hasNext() && i2.hasNext())
    {
        Object k1 = i1.next();
        Object k2 = i2.next();
        if (0!=(i=stringFallbackComparator.compare(k1, k2)))
            return i;
        if (0!=(i=stringFallbackComparator.compare(m1.get(k1), m2.get(k2))))
            return i;
    }
    if (i1.hasNext())
        return 1;
    if (i2.hasNext())
        return -1;
    return 0;
}
另一答案

这个问题很古老,但仍然相关。

如果要按照与键匹配的值比较两个映射,可以执行以下操作:

public static <K, V> boolean mapEquals(Map<K,

以上是关于如何根据值来比较两个地图的主要内容,如果未能解决你的问题,请参考以下文章

如何在android的地图中获取当前位置?

如何从片段外部清除/重置地图?

如何在滚动视图中设置谷歌地图片段

如何更改谷歌地图标记上方的标题和片段设计

如何在地图片段 API v2 布局顶部添加按钮

如何在用java创建的布局内创建地图片段(GoogleMap)?