How can I check if two ArrayList differ, I don't care what's changed

Question

How can I check if two ArrayLists differ from one another? I don't care what's the difference, I just want to know if they're not the same.

I'm fetching scores list from a database every minute, and only if the scores list that I fetched is different from the one I fetched a minute ago I want to send it to the client.

Now the value of the ArrayList is actually a class that I created (that contains name, lvl, rank, score).

Do I need to implement equals() on it?

Answer 1

On the definition of "sameness"

As Joachim noted, for most application, List.equals(Object o) definition works:

Compares the specified object with this list for equality. Returns true if and only if the specified object is also a list, both lists have the same size, and all corresponding pairs of elements in the two lists are equal. (Two elements e1 and e2 are equal if (e1==null ? e2==null : e1.equals(e2)).) In other words, two lists are defined to be equal if they contain the same elements in the same order. This definition ensures that the equals method works properly across different implementations of the List interface.

Depending on how you're using it, though, this may not work as expected. If you have a List<int[]>, for example, it doesn't quite work because arrays inherit equals from Object which defines equality as reference identity.

    List<int[]> list1 = Arrays.asList(new int[] { 1, 2, 3 });
    List<int[]> list2 = Arrays.asList(new int[] { 1, 2, 3 });
    System.out.println(list1.equals(list2)); // prints "false"

Also, two lists with different type parameter can be equals:

    List<Number> list1 = new ArrayList<Number>();
    List<String> list2 = new ArrayList<String>();
    System.out.println(list1.equals(list2)); // prints "true"

You also mentioned that the list must contain elements with the same type. Here's yet another example where the elements don't have the same type, and yet they're equals:

    List<Object> list1 = new ArrayList<Object>();
    List<Object> list2 = new ArrayList<Object>();
    list1.add(new ArrayList<Integer>());
    list2.add(new LinkedList<String>());
    System.out.println(list1.equals(list2)); // prints "true"

So unless you clearly define what equality means to you, the question can have very different answers. For most practical purposes, though, List.equals should suffice.

---

On implementing equals

Information after update suggests that List.equals will do the job just fine, provided that the elements implement equals properly (because List<E>.equals invokes E.equals on the non-null-elements, per the API documentation above).

So in this case, if we have, say, a List<Player>, then Player must @Override equals(Object o) to return true if o instanceof Player and on the relevant fields, they're all equals (for reference types) or == (for primitives).

Of course, when you @Override equals, you should also @Override int hashCode(). The barely acceptable minimum is to return 42;; slightly better is to return name.hashCode();; best is to use a formula that involves all the fields on which you define equals. A good IDE can automatically generate equals/hashCode methods for you.

See also

• Effective Java 2nd Edition
  • Item 8: Obey the general contract when overriding equals
  • Item 9: Always override hashcode when you override equals

API links

• Object.equals(Object)
• Object.hashCode()
• java.lang.Comparable - not needed here, but another important Java API contract

Related questions

On equals/hashCode combo:

• Overriding equals and hashcode in Java
• Why both hashCode() and equals() exist
• How to ensure hashCode() is consistent with equals()?

On equals vs ==:

• Difference between equals and ==
• why equals() method when we have == operator?
• Java String.equals versus ==

Answer 2

Use equals(). As long as the elements inside the lists implement equals() correctly it will return the correct values.

Unless you want to ignore the order of the values, then you should dump the values in two Set objects and compare those using equals().

Answer 3

Here's a simple method that checks if 2 Array Lists contain the same values regardless their order.

 //the name of the method explains it well...
    public boolean isTwoArrayListsWithSameValues(ArrayList<Object> list1, ArrayList<Object> list2)
    {
        //null checking
        if(list1==null && list2==null)
            return true;
        if((list1 == null && list2 != null) || (list1 != null && list2 == null))
            return false;

        if(list1.size()!=list2.size())
            return false;
        for(Object itemList1: list1)
        {
            if(!list2.contains(itemList1))
                return false;
        }

        return true;
    }

Answer 4

As @Joachim Sauer mentioned in his answer, equals should work if the lists are equal and their contents implement equals correctly. But, it shouldn't work if the items are not in the same "order" since it doesn't use contains for the check. In this sense, it checks for "strict" equality as mentioned by @jarnbjo

        //From android's Arraylist implementation
        Iterator<?> it = that.iterator();
        for (int i = 0; i < s; i++) {
            Object eThis = a[i];
            Object eThat = it.next();
            if (eThis == null ? eThat != null : !eThis.equals(eThat)) {
                return false;
            }
        }

However, I wanted somewhat different behaviour, I didn't care about order or anything like that. All I wanted was to be sure the two didn't contain the same items. My solution,

    //first check that both are not null and are of same length. (not shown here)
    //if both match, pull out the big guns as below
    ...
    List<Object> comparedList = new ArrayList<>(listOne);
    comparedList.removeAll(listTwo);
    if(comparedList.size() != 0) //there are differences between the two

This is less performant since it loops twice, first in removeAll and then in contains which is called by removeAll.

My list was guaranteed to be short so I didn't mind the hit.

Answer 5

You can convert them to string and then compare like

list1.toString().equals(list2.toString())

Answer 6

You can also check the Arraylist as shown below:

public  boolean equalLists(List<String> one, List<String> two){     
if (one == null && two == null){
    return true;
}

if((one == null && two != null) 
  || one != null && two == null
  || one.size() != two.size()){
    return false;
}

//to avoid messing the order of the lists we will use a copy
//as noted in comments by A. R. S.
one = new ArrayList<String>(one); 
two = new ArrayList<String>(two);   

Collections.sort(one);
Collections.sort(two);      
return one.equals(two);
}

Thanks to @Jacob