8

I have the following HashMap with properties keys and values:

private HashMap<String, Object> prop_values;

I need to check if one instance of it is equal to another one. In the past, i just did this:

if (prop_values_1.equals(prop_values_2)){
   //  do something
}

And this worked until i got Object[] as a value. So, my previous expression always returned false on such HashMap with any Object[] value.

So, i have to implement this method:

private boolean isPropValuesEquals(HashMap<String, Object> pv1, HashMap<String, Object> pv2){
   boolean isEquals = true;

   if (pv1 == null || pv2 == null){
      return false;
   }

   if (!pv1.keySet().equals(pv2.keySet())){
      return false;
   }

   for (String key : pv1.keySet()){

      Object cur_pv1 = pv1.get(key);
      Object cur_pv2 = pv2.get(key);

      if (cur_pv1 instanceof Object[]){
         if (cur_pv2 instanceof Object[]){
            isEquals = Arrays.equals((Object[])cur_pv1, (Object[])cur_pv2);
         } else {
            return false;
         }
      } else {
         isEquals = isEquals && cur_pv1.equals(cur_pv2);
      }

      if (!isEquals){
         return false;
      }
   }

   return isEquals;

}

It works, but it seems to be some kind of hack, and i'm not sure this is the best way to achieve what I need.

So, here's two questions:

  • why Object[].equals() is not the same as Arrays.equals()? It seems to be painful.

  • is there some better way to compare HashMap<String, Object>, if values can be an Object[] ?

Improve this question
3
  • 1
    Use a List<Object> instead of an Object[], and everything will work as you expect it to do. Commented Apr 19, 2012 at 7:52
  • @JBNizet, there is another kind of pain with Type safety warning when casting from Object to parametrized type like List<Object>. Commented Apr 19, 2012 at 8:21
  • You have warnings, but it's not less safe than casting to Object[]. Just encapsulate everything correctly and make sure that you have robust code. Commented Apr 19, 2012 at 8:46

6 Answers 6

Reset to default
3

The deep problem is that an there's no way to override the equals() of an array. Why it's not written as "equal elements in the same order" in the first place, I have no idea. It definitely could have been (unless there's some obscure rationale for not doing it; I can't think of any; if you wanted to check for reference equality, you use ==, so what would a working equals() harm?).

Your solution is the way to go. Just a couple of details to consider:

  • Instead of x instanceof Object[], you could use x.getClass().isArray(), so it would work for other arrays as well, such as int[] (which is not a subclass of Object[]). Downside: you may have to separately check if x is null.

  • If the arrays may contain nested arrays, consider using Arrays.deepEquals().

A demonstration that primitive arrays are not Object[]s:

    Object a = new int[1];
    System.out.println("" + (a instanceof Object[])); // false
    System.out.println("" + a.getClass().isArray()); // true

Yet another pain in the arse is that even if you find that x is an array, you still have to handle separately cases for all the different primitive element types. There's no way to handle them in a generic way in Java's type system. Of course, if you don't have primitive arrays in our map, then you don't need to handle this case.

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

This is a slightly obscure aspect of Java, but actually ALL arrays are instanceof Object[]! BTW if equals was implemented any other way than it is, it would break more things than fix, I think. For one, arrays are expected to be a raw, extremely efficient kind of object.
for me (new String[] { "foo", "bar" } instanceof Object[]) returns true, i have tested it before implementing this method. So, String[] is a subclass of Object[]. Could you please elaborate on this? Maybe not all versions of Java have such behavior? And thanks for deepEquals().
I can assure you that all versions of Java behave that way. When studying Scala and its type covariance/contravariance, I once read a quote of Gosling who said that yes, they were aware of the fact that type covariance makes little sense for an array, but they made it like that to facilitate just the kind of case you have, and also make passing any array as argument possible.
Oops, screwed it up, fixed. But primitive arrays are not Object[]s.
@MarkoTopolnik, thanks, but i just checked that int[] is not an instance of Object[]. So, you was wrong in your first comment. I think i need to do what Joonas Pulakka suggested: x.getClass().isArray()
|
0

Equality can be different things: is it the same reference (reference equality)? Or does it have the same contents?

The issue with arrays is that they are mutable. equals and hashCode of an object must always come as pairs, and the hash code should not change (otherwise objects cannot be found in hash tables). Therefore the normal equals (and hashCode) cannot use the arrays content, they have to rely on another (non-mutable) property of the array, which is the reference.

Improve this answer

4 Comments

Nothing forbids a hashCode to change. BTW, two lists are equal if they contain equal objects in the same order. The same could have been don with arrays, but hasn't (and probably never will, for backward-compatibility reasons).
@JBNizet Add object A to a hashed collection. If the hash of A changes, it will be in the wrong bucket and all operations on the hashed collection will fail for that object (such as "contains" etc.).
Yes, but that doesn't mean that A.hashCode is buggy. It makes your usage of A buggy.
I guess there is no definitive answer on this topic really. While I agree that the specs don't forbid a mutable hashCode for mutable objects (and some objects such as List do have this property) it does hold a potential for hard to track bugs.
0

The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).

Improve this answer

Comments

0 
why Object[].equals() is not the same as Arrays.equals()?
  • Object1.equals(Object2) is the same as Object1 == Object2, i.e. comparing of addresses of the objects (this is not expected by a lot of developers but this is unfortunately true)
  • Arrays.equals(array1, array2) compares the contents of the arrays.

For the first point:
This is the most abstract of equals() method, the same way as all classes extend from Object. String.equals(String) is the overridden case of that method where it works like Arrays.equals(array1, array2).By doing this, they paved the way for other developers to override it for their purposes to be most flexible.

It's better to use List<Object> instead of Object[], because it has all the methods ready and can satisfy for all purposes.

Improve this answer

9 Comments

This is what the java community devs coded, these are their rules
This is the most abstract of equals method the same way as all classes extend from Object String.equals(String) is the overridden case of that method where it works like Arrays.equals(array1, array2)
They paved the way for other developers o override it for their purposes to be most flexible
man better to use List<Object> instead of Object[], because it has all the methods ready and can satisfy for all purposes
Why would you cast just use HashMap<String, List<Object>> as simple as that. if you are going to cast and you have warnings just use: suppresswarnings
|
0

A nice, but also inefficient implementation is to

  • copy the map
  • replace any arrays with wrapped list
  • do the comparison using standard .equals(), this will work because the list wrappers will do a proper deep equals on the underlying array.

Code 

public static Map<String, Object> arraysToLists(Map<String, Object> map) {
    Map<String, Object> copy = new HashMap<String, Object>(map);
    for (Entry<String, Object> entry : copy.entrySet()) {
        if (entry.getValue() instanceof Object[]) {
            entry.setValue(Arrays.asList((Object[]) entry.getValue()));
        }
    }
    return copy;
}

public static boolean mapCompare(Map<String, Object> map1,
        Map<String, Object> map2) {
    return arraysToLists(map1).equals(arraysToLists(map2));
}

Test case

public static void main(String[] args) {
    Map<String, Object> testA = new HashMap<String, Object>();
    testA.put("foo", new Object[] { "1", "2" });
    Map<String, Object> testB = new HashMap<String, Object>();
    testB.put("foo", new Object[] { "1" });
    Map<String, Object> testC = new HashMap<String, Object>();
    testC.put("foo", new Object[] { "1", "2" });

    // demonstrate equals() broken with Object arrays
    System.out.println(testA.equals(testB)); // expect false
    System.out.println(testA.equals(testC)); // expect true

    // demonstrate new function works OK
    System.out.println(mapCompare(testA, testB)); // expect false
    System.out.println(mapCompare(testA, testC)); // expect true
}

Output

false
false
false
true
Improve this answer

Comments

0

Joonas is correct, however I would refactor your code to be the following. You can check over it yourself to find the differences.

private static boolean isPropValuesEquals(Map<String, Object> pv1, Map<String, Object> pv2) {
    if (pv1 == null || pv2 == null || pv1.size() != pv2.size())
        return false;

    for (Map.Entry<String, Object> entry : pv1.entrySet()) {
        Object cur_pv1 = entry.getValue();
        Object cur_pv2 = pv2.get(entry.getKey());

        if (cur_pv1 == null ^ cur_pv2 == null) // if exactly one is null they're "not equal"
            return false;

        if (cur_pv1 != null) {
            if (cur_pv1.getClass().isArray()) {
                if (Arrays.deepEquals((Object[]) cur_pv1, (Object[]) cur_pv2))
                    return false;
            } else {
                if (!cur_pv1.equals(cur_pv2)) {
                    return false;
                }
            }
        }
    }

    return true;
}
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.