Is there a Comparator> or Comparator>?

Question

I am searching for a class that implements one of the following

java.util.Comparator<int[]>
java.util.Comparator<List<T>>
java.util.Comparator<Collection<T>>

Why is there no such class in the Java Standard Library / Apache Common / Google Guava ?

Because there's no *one* standard way of comparing collections (by length, by the ugliness of the first element?) as there is for comparing numbers. — webuster, Aug 28 '14 at 12:16
I guess you are asking whether there is a handy class that provides the [lexicographical ordering](http://en.wikipedia.org/wiki/Lexicographical_ordering) of a collection. For that you need a `Comparator< List >` or you must provide a `Comparator`. — Raedwald, Aug 28 '14 at 12:20
its like asking which burger is the best and is there a way to compare burgers(different food magazines will have different burger compariosn) — Kumar Abhinav, Aug 28 '14 at 12:21
@webuster there is a standard way of comparing strings, comparing collections should have same behavior — Morad, Aug 28 '14 at 13:30
@Morad You can make an analogy to strings, which does make sense, but what I meant is that there are collections which do not have an order/succession to them (think `Set`s) the way strings do. What I believe you need is what @Raedwald suggested. — webuster, Aug 28 '14 at 13:55

ColinD · Accepted Answer · 2014-08-28T14:41:27.667

2

Guava's Ordering class provides lexicographical ordering of Iterables that uses a base Ordering to compare each pair of elements.

Ordering<T> elementOrdering = ...
Ordering<Iterable<T>> lexicographical = elementOrdering.lexicographical();

edited Aug 28 '14 at 14:41

answered Aug 28 '14 at 14:34

ColinD

108,630
30
201
202

score 0 · Answer 2 · answered Aug 28 '14 at 12:43

Apache Commons Collections has a ComparatorChain that could be what you are looking for.

But implementing a lexicographical comparator is not so hard either:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LexicographicalComparatorsTest
{
    public static void main(String[] args)
    {
        List<List<String>> lists = new ArrayList<List<String>>();
        lists.add(Arrays.asList("A", "B", "4"));
        lists.add(Arrays.asList("A", "B", "1"));
        lists.add(Arrays.asList("A", "B", "3"));
        lists.add(Arrays.asList("A", "B", "2"));
        lists.add(Arrays.asList("A", "A", "9"));
        lists.add(Arrays.asList("A", "C", "0"));

        Comparator<String> c = comparableComparator();
        Comparator<List<String>> cc = createCompatator(c);

        Collections.sort(lists, cc);
        for (List<String> list : lists)
        {
            System.out.println(list);
        }
    }

    private static <T extends Comparable<T>> Comparator<T> comparableComparator()
    {
        return new Comparator<T>()
        {
            @Override
            public int compare(T t0, T t1)
            {
                return t0.compareTo(t1);
            }
        };
    }

    public static <T> Comparator<List<T>> createCompatator(
        final Comparator<T> comparator)
    {
        return new Comparator<List<T>>()
        {
            @Override
            public int compare(List<T> list0, List<T> list1)
            {
                int n = Math.min(list0.size(), list1.size());
                for (int i=0; i<n; i++)
                {
                    T t0 = list0.get(i);
                    T t1 = list1.get(i);
                    int result = comparator.compare(t0, t1);
                    if (result != 0)
                    {
                        return result;
                    }
                }
                return 0;
            }
        };
    }
}

A colexicographical comparator can be implemented by reversing the list traversal direction.

The comparator in this example could also be generalized to a Comparator<Collection<T>>, by using manual traversal with two Iterator<T> instances obtained from the collections.

You'll also want to break ties based on the length of the list ("a" < "aa"). (Guava's `Ordering.lexicographical()`, recommended below, has code for this, so if you use that, you'll be good.) — Chris Povirk, Aug 29 '14 at 19:07

Is there a Comparator> or Comparator>?

2 Answers2