Implementing Comparable/compareTo for a class with a collections member field

[Salman Ahmed]

Say I have a class defined as follows:

public class Widget {
     public Widget(String id, String name, Set<String> properties) {
         this.id = id;
         this.name = name;
         this.properties = properties;
     }
 
     public String getId() {
         return id;
     }
 
     public String getName() {
         return name;
     }
 
     public Set<String> getProperties() {
         return properties;
     }
 
     private final String id;
     private final String name;
     private final Set<String> properties; 
}

and I want to implement the Comparable interface for it.

Are there any standard library utilities available for comparing two collection objects and returning a (-1, 0, 1) based on how those two Collections object compare to one another?

Or do I have to write my own helper/utility method to compare two Collection instances:

public int compareTo(Widget other) {
    int comparison = ComparableHelper.compareTo(this.getId(), other.getId());
    if (comparison == ComparableHelper.EQUAL) {
        comparison = ComparableHelper.compareTo(this.getName(), other.getName());
    }
    if (comparison == ComparableHelper.EQUAL) {
        [B]comparison = ComparableHelper.compareTo(this.getProperties(), other.getProperties());[/B]
    }
 
    return comparison;
}

More generally speaking, what's best practice when dealing with such classes that have to be Comparable and that contain collections member fields?

Thanks.

[Rob Spoor]

There are different strategies for this, but I think the most common one is this:
- iterate through both collections at the same time
- compare element i of collection 1 to element i of collection 2 (order determined by the collection*)
- if different return that difference
- loop until either collection is traversed

If collection 1 still has elements return 1.
If collection 2 still has elements return -1.
If neither collection has elements left return 0.


Now the biggest problem will be in the order (see *). If a HashSet and TreeSet contain the same elements but return those in a different order, are the collections then regarded as the same?

You could solve this by using a TreeSet as intermediate solution (new TreeSet(collection1) etc) because those have an order of themselves, but is this what you want? Is the order of a List important or isn't it?

Not as simple as one might think.

[Salman Ahmed]

OK, so I came up with the following utility method:

    public static <T extends Comparable<T>> int compareTo(Set<T> a, Set<T> b) {
        /* first compare based on the size of the two collections */
        int comparison = compareTo(a.size(), b.size());
        if (comparison == ComparableHelper.EQUAL) {
            /* then check if both collections are equal */
            if (a.equals(b)) {
                comparison = ComparableHelper.EQUAL;
            }
            else {
                for (Iterator<T> itA = a.iterator(), itB = b.iterator(); itA.hasNext() :wink:  {
                    T elemFromA = itA.next();
                    T elemFromB = itB.next();
 
                    /* lastly compare each pair of elements from both
                     * collections */
                    comparison = elemFromA.compareTo(elemFromB);
                    if (comparison != ComparableHelper.EQUAL) {
                        return comparison;
                    }
                }
            }
        }
 
        return comparison;
    }
 

but I didn't realize that different collections will return different orderings - thanks for pointing that out. The TreeSet solution works me since in my application I know that I will ALWAYS be comparing collection instances of the same type.

Does this 2nd version of the code look right:

    public static <T extends Comparable<T>> int compareTo2(Collection<T> a, Collection<T> b) {
        /* first compare based on the size of the two collections */
        int comparison = compareTo(a.size(), b.size());
        if (comparison == ComparableHelper.EQUAL) {
            /* then check if both collections are equal */
            if (a.equals(b)) {
                comparison = ComparableHelper.EQUAL;
            }
            else {
                TreeSet<T> t1 = new TreeSet<T>(a);
                TreeSet<T> t2 = new TreeSet<T>(b);
                for (Iterator<T> it1 = t1.iterator(), it2 = t2.iterator(); it1.hasNext() :wink:  {
                    T elemFrom1 = it1.next();
                    T elemFrom2 = it2.next();
 
                    /* lastly compare each pair of elements from both
                     * collections */
                    comparison = elemFrom1.compareTo(elemFrom2);
                    if (comparison != ComparableHelper.EQUAL) {
                        return comparison;
                    }
                }
            }
        }
 
        return comparison;
    }

Thanks Rob!

[Pavan Kumar Srinivasan]

Using a Comparator over Comparable also has many advantages and can be considered a viable option

1: If the class is final or non-modifiable
2: Comparable allows us to have only one implementation ...inside the comapareTo method, We can instead have different comparator implmentations for the same class .

[Campbell Ritchie]

Pavan Kumar Srinivasan, useful point, thank you, and welcome to JavaRanch

[Rob Spoor]

Both solutions look find to me. You already know that the elements in your Collections are Comparable so that's not going to be a problem with TreeSet.

And see what I mean with different algorithms? Apparently, for you size is more important than the contents.