Comparator interface contains only two methods:
int compare(T o1, T o2)
boolean equals(Object obj).

List interface contains no sort method.
Collection interface contains no sort method.

Collections class contains two sort methods:
static <T extends Comparable<? super T>> void  sort(List<T> list)
static <T> void  sort(List<T> list, Comparator<? super T> c).

So, you'll have to write your own method.

Create an ArrayList<MyObj> using the Collection objects as the
constructor parameter. Apply Collections.sort to the List<MyObj> with a
Comparator to do the sorting.

That reduces the problem to writing a Comparator<MyObj> that orders
based on a list of fields. Do you have a plan yet for specifying the
list of fields? Are they all Comparable?

Patricia

On Wed, 14 Nov 2007 13:03:52 +0530, "Manish Hatwalne"
<manish@nospam.com> wrote, quoted or indirectly quoted someone who
said :

see http://mindprod.com/jgloss/sort.html
and http://mindprod.com/jgloss/comparator.html

There is a code for a Comparator that sorts arrays of fields, given a
list of which cols to sort.

The basic idea is to compare a high order field.  If they differ you
are done. If not you compare the next higher order field.

On Wed, 14 Nov 2007 13:03:52 +0530, "Manish Hatwalne"
<manish@nospam.com> wrote, quoted or indirectly quoted someone who
said :

Sort uses Comparable. You get only two parameters.  These are
references to Objects.  Inside your compare method you look at the
various fields in the objects.

Sorting a list of objects by some attribute or function of the object,
rather than the object itself, is a frequent agony in Java.  In the
past, I've created all sorts of abstract classes (IntFunction,
DoubleFunction, etc) to substitute for the lambda expression/closure
language construct you really need for this.   But I recently thought of
a Better Way.  <Smack forehead> that I did not think of it years ago.

A loose exposition:

// Prepping.  This can be done in three lines if the value is an
// expression.
List<Comparable> values = new ArrayList<Comparable>();
for (Whatever x : list) {
  // Compute the value you want to sort on and add to list
  ....
  values.add(value);
}

// Now the sorting, which calls the magic function.  DONE!  That's four
// lines and minimal pain
Sorting.sortAscending(list,values);  // there's a sortDescending too

// How does it work?  Here's the code.

// There's a sortDescending too.  I can never remember the order so
// I make it explicit in the name.
public static void sortAscending (List objects, List<Comparable> values)
{
   // Set up the sort pairs
   List<SortPair> sortPairs = new ArrayList<SortPair>();
   for (int i=0;i<list.size();i++)
     sortPairs.add(new SortPair(list.get(i),values.get(i));

   //  Sort them
   Collections.sort(sortPairs);

   // Stick the objects back in the list.   That's it.
   for (int i=0;i<list.size();i++)
     list.set(i,sortPairs.get(i).object);
}

// The SortPair can be an inner class of Sorting if desired
class SortPair implements Comparable
{
  Object object;       
  Comparable value;

  //
  SortPair (Object object, Comparable value)  {
    this.object = object;
    this.value = value;
  }

  // The compareTo just delegates to the object
  public int comparable (SortPair other) {
    return value.compareTo(other.value);
  }
}