How do I sort a list by different parameters at different timed

I have a class named Person with multiple properties, for example:

public class Person {
    private int id;
    private String name, address;
    // Many more properties.
}

A lot of Person-objects are stored in an ArrayList<Person>. I want to sort this list by multiple sort parameters, and different from time to time. For instance I might one time want to sort by name ascending and then address descending, and another time just by id descending.

And I don't want to create my own sort methods (i.e., I want to use Collections.sort(personList, someComparator). What is the most elegant solution that achieves this?

I think your enum approach is basically sound, but the switch statements really need a more object oriented approach. Consider:

enum PersonComparator implements Comparator<Person> {
    ID_SORT {
        public int compare(Person o1, Person o2) {
            return Integer.valueOf(o1.getId()).compareTo(o2.getId());
        }},
    NAME_SORT {
        public int compare(Person o1, Person o2) {
            return o1.getFullName().compareTo(o2.getFullName());
        }};
    
    public static Comparator<Person> decending(final Comparator<Person> other) {
        return new Comparator<Person>() {
            public int compare(Person o1, Person o2) {
                return -1 * other.compare(o1, o2);
            }
        };
    }

    public static Comparator<Person> getComparator(final PersonComparator... multipleOptions) {
        return new Comparator<Person>() {
            public int compare(Person o1, Person o2) {
                for (PersonComparator option : multipleOptions) {
                    int result = option.compare(o1, o2);
                    if (result != 0) {
                        return result;
                    }
                }
                return 0;
            }
        };
    }
}

An example of usage (with a static import).

public static void main(String[] args) {
    List<Person> list = null;
    Collections.sort(list, decending(getComparator(NAME_SORT, ID_SORT)));
}

You can create comparators for each of properties you might want to sort and then try "comparator chaining" :-) like this:

public class ChainedComparator<T> implements Comparator<T> {
    private List<Comparator<T>> simpleComparators; 
    public ChainedComparator(Comparator<T>... simpleComparators) {
        this.simpleComparators = Arrays.asList(simpleComparators);
    }
    public int compare(T o1, T o2) {
        for (Comparator<T> comparator : simpleComparators) {
            int result = comparator.compare(o1, o2);
            if (result != 0) {
                return result;
            }
        }
        return 0;
    }
}

One way is to create a Comparator that takes as arguments a list of properties to sort by, as this example shows.

public class Person {
    private int id;
    private String name, address;

    public static Comparator<Person> getComparator(SortParameter... sortParameters) {
        return new PersonComparator(sortParameters);
    }

    public enum SortParameter {
        ID_ASCENDING, ID_DESCENDING, NAME_ASCENDING,
        NAME_DESCENDING, ADDRESS_ASCENDING, ADDRESS_DESCENDING
    }

    private static class PersonComparator implements Comparator<Person> {
        private SortParameter[] parameters;

        private PersonComparator(SortParameter[] parameters) {
            this.parameters = parameters;
        }

        public int compare(Person o1, Person o2) {
            int comparison;
            for (SortParameter parameter : parameters) {
                switch (parameter) {
                    case ID_ASCENDING:
                        comparison = o1.id - o2.id;
                        if (comparison != 0) return comparison;
                        break;
                    case ID_DESCENDING:
                        comparison = o2.id - o1.id;
                        if (comparison != 0) return comparison;
                        break;
                    case NAME_ASCENDING:
                        comparison = o1.name.compareTo(o2.name);
                        if (comparison != 0) return comparison;
                        break;
                    case NAME_DESCENDING:
                        comparison = o2.name.compareTo(o1.name);
                        if (comparison != 0) return comparison;
                        break;
                    case ADDRESS_ASCENDING:
                        comparison = o1.address.compareTo(o2.address);
                        if (comparison != 0) return comparison;
                        break;
                    case ADDRESS_DESCENDING:
                        comparison = o2.address.compareTo(o1.address);
                        if (comparison != 0) return comparison;
                        break;
                }
            }
            return 0;
        }
    }
}

It can then be used in code for instance like this:

cp = Person.getComparator(Person.SortParameter.ADDRESS_ASCENDING,
                          Person.SortParameter.NAME_DESCENDING);
Collections.sort(personList, cp);

One approach would be to compose Comparators. This could be a library method (I'm sure it exists somewhere out there).

public static <T> Comparator<T> compose(
    final Comparator<? super T> primary,
    final Comparator<? super T> secondary
) {
    return new Comparator<T>() {
        public int compare(T a, T b) {
            int result = primary.compare(a, b);
            return result==0 ? secondary.compare(a, b) : result;
        }
        [...]
    };
}

Use:

Collections.sort(people, compose(nameComparator, addressComparator));

Alternatively, note that Collections.sort is a stable sort. If performance isn't absolutely crucial, you sort be the secondary order before the primary.

Collections.sort(people, addressComparator);
Collections.sort(people, nameComparator);

Comparators lets you do that very easily and naturally. You can create single instances of comparators, either in your Person class itself, or in a Service class associated to your need.
Examples, using anonymous inner classes:

    public static final Comparator<Person> NAME_ASC_ADRESS_DESC
     = new Comparator<Person>() {
      public int compare(Person p1, Person p2) {
         int nameOrder = p1.getName().compareTo(p2.getName);
         if(nameOrder != 0) {
           return nameOrder;
         }
         return -1 * p1.getAdress().comparedTo(p2.getAdress());
         // I use explicit -1 to be clear that the order is reversed
      }
    };
    
    public static final Comparator<Person> ID_DESC
     = new Comparator<Person>() {
      public int compare(Person p1, Person p2) {
         return -1 * p1.getId().comparedTo(p2.getId());
         // I use explicit -1 to be clear that the order is reversed
      }
    };
    // and other comparator instances as needed... 

---

If you have many, you can also structure your comparators code any way you like. For example, you could:

• inherit from another comparator,
• have a CompositeComparator that agregates some existing comparators
• have a NullComparator that handle null cases, then delegates to another comparator
• etc...

I think coupling the sorters to the Person class, like in your answer, isn't a good idea, because it couples the comparison (usually business driven) and the model object to close to each other. Each time you want to change/add something the sorter, you need to touch the person class, which is usually something you do not want to do.

Using a Service or something similar, which provides Comparator instances, like KLE proposed, sounds way more flexible and extensible.

My approach is build on Yishai's. The main gap is that there is no way to sort first ascending for an attribute and after that decending for an other one. This can not be done with enumerations. For that I used classes. Because the SortOrder strongly depends on the type I prefered to implement it as an inner class of person.

The class 'Person' with inner class 'SortOrder':

import java.util.Comparator;

public class Person {
    private int id;
    private String firstName; 
    private String secondName;

    public Person(int id, String firstName, String secondName) {
	    this.id = id;
	    this.firstName = firstName;
	    this.secondName = secondName;	
    }

    public abstract static class SortOrder implements Comparator<Person> {
    	public static SortOrder PERSON_ID = new SortOrder() {
    		public int compare(Person p1, Person p2) {
                return Integer.valueOf(p1.getId()).compareTo(p2.getId());
            }
        };
        public static SortOrder PERSON_FIRST_NAME = new SortOrder() {
        	public int compare(Person p1, Person p2) {
                return p1.getFirstName().compareTo(p2.getFirstName());
            }
        };
        public static SortOrder PERSON_SECOND_NAME = new SortOrder() {
        	public int compare(Person p1, Person p2) {
                return p1.getSecondName().compareTo(p2.getSecondName());
            }
        };

        public static SortOrder invertOrder(final SortOrder toInvert) {
        	return new SortOrder() {
	    		public int compare(Person p1, Person p2) {
				    return -1 * toInvert.compare(p1, p2);
			    }
		    };
        }
    
        public static Comparator<Person> combineSortOrders(final SortOrder... multipleSortOrders) {
            return new Comparator<Person>() {
                public int compare(Person p1, Person p2) {
                    for (SortOrder personComparator: multipleSortOrders) {
                        int result = personComparator.compare(p1, p2);
                        if (result != 0) {
                            return result;
                        }
                    }
                    return 0;
                }
            };
        }
    }

    public int getId() {
    	return id;
    }

	public String getFirstName() {
    	return firstName;
    }

	public String getSecondName() {
    	return secondName;
	}

	@Override
    public String toString() {
	    StringBuilder result = new StringBuilder();
	
		result.append("Person with id: ");
    	result.append(id);
	    result.append(" and firstName: ");
		result.append(firstName);
    	result.append(" and secondName: ");
	    result.append(secondName);
		result.append(".");
	
    	return result.toString();
    }
}

An example for using the class Person and its SortOrder:

import static multiplesortorder.Person.SortOrder.*;

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

import multiplesortorder.Person;

public class Application {

    public static void main(String[] args) {
	    List<Person> listPersons = new ArrayList<Person>(Arrays.asList(
			     new Person(0, "...", "..."),
			     new Person(1, "...", "...")
			 ));
	 
		 Collections.sort(listPersons, combineSortOrders(PERSON_FIRST_NAME, invertOrder(PERSON_ID)));
	 
	     for (Person p: listPersons) {
		     System.out.println(p.toString());
	     }
    }
}

oRUMOo

I recently wrote a Comparator to sort multiple fields within a delimited String record. It allows you to define the delimiter, record structure and sorting rules (some of which are type-specific). You can use this by converting a Person record into a delimited String.

Required information is seeded to the Comparator itself, either programmatically or through an XML file.

XML is validated by a package embedded XSD file. For example, below is a tab delimited record layout with four fields (two of which are sortable):

<?xml version="1.0" encoding="ISO-8859-1"?> 
<row xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <delimiter>&#009;</delimiter>

    <column xsi:type="Decimal">
        <name>Column One</name>
    </column>

    <column xsi:type="Integer">
        <name>Column Two</name>
    </column>

    <column xsi:type="String">
        <name>Column Three</name>
        <sortOrder>2</sortOrder>
        <trim>true</trim>
        <caseSensitive>false</caseSensitive>        
        <stripAccents>true</stripAccents>
    </column>

    <column xsi:type="DateTime">
        <name>Column Four</name>
        <sortOrder>1</sortOrder>
        <ascending>true</ascending>
        <nullLowSortOrder>true</nullLowSortOrder>
        <trim>true</trim>
        <pattern>yyyy-MM-dd</pattern>
    </column>

</row>

You would then use this in java like so:

Comparator<String> comparator = new RowComparator(
              new XMLStructureReader(new File("layout.xml")));

Library can be found here:

http://sourceforge.net/projects/multicolumnrowcomparator/

Suppose a class Coordinate is there and one has to sort it in both ways according to X-coordinate and Y-coordinate. Two differnet comparators is needed for it. Below is the sample

class Coordinate
{

	int x,y;
	
	public Coordinate(int x, int y) {
		this.x = x;
		this.y = y;
	}

	static Comparator<Coordinate> getCoordinateXComparator() {
        return new Comparator<Coordinate>() {

			@Override
			public int compare(Coordinate Coordinate1, Coordinate Coordinate2) {
				if(Coordinate1.x < Coordinate2.x)
					return 1;
				else
					return 0;
			}
            // compare using Coordinate x
        };
    }

    static Comparator<Coordinate> getCoordinateYComparator() {
        return new Comparator<Coordinate>() {

			@Override
			public int compare(Coordinate Coordinate1, Coordinate Coordinate2) {
				if(Coordinate1.y < Coordinate2.y)
					return 1;
				else
					return 0;
			}
            // compare using Coordinate y
        };
    }
}