Well there's nothing wrong with it, but one use Collections is when you
don't know how many elements there are ahead of time.

You could use an ArrayList of objects that you define, implement
Comparable on these objects, then use Colections.sort, but then again an
object to hold four numbers may be a bit much. The natural way would be
to use arrays.

To do it your way have a look at this, the code needs tidying up to deal
with cases where you don't get exactly what you want, but this runs and
shows the concept. It's a JUnit test case, but you could wrap it all in
a main() instead if you wanted. The key is the Comparator that
Collections.sort allows you to provide. Also it will be a lot neater if
you are using 1.5 (which I think you are).

James

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

import junit.framework.TestCase;

/**
 * @author jw2328
 *
 */
public class ArrayListTest extends TestCase {

    public void testNothing() {

        List a = new ArrayList();

        List b = new ArrayList();

        b.add(new Integer(1));
        b.add(new Integer(2));

        List c = new ArrayList();

        c.add(new Integer(3));
        c.add(new Integer(4));

        a.add(c);
        a.add(b);

        Iterator it = a.iterator();

        while (it.hasNext()) {
            System.out.println(((ArrayList) it.next()).get(0));
        }

        Collections.sort(a, new Comparator() {

            public int compare(Object o1, Object o2) {
                Integer a = (Integer) ((ArrayList) o1).get(0);
                Integer b = (Integer) ((ArrayList) o2).get(0);
                return a.compareTo(b);
            }
        });

        System.out.println("Sorted:");

        it = a.iterator();

        while (it.hasNext()) {
            System.out.println(((ArrayList) it.next()).get(0));
        }

    }

}

   You might want to define a class to encapsulate these for values. For
example:

<code>
class Edge implements Comparable<Edge> {
 double yMin, yMax, xValue, inverseM;

 /*Implement the compareTo method here*/
}

ArrayList<Edge> myFoos = new ArrayList<Edge>();
</code>

   - Oliver

for a fixed known number of elements, an array is the way to fly. They
are much faster and the type safety is not nearly so flaky.