CODE: Dynamic Sorting on Multiple Indexes

[Cindy Carney]

Here's a handy utility called “DynamicComparer”, that will dynamically sort an array or ArrayList on multiple fields, in ascending or descending order, without or without case sensitivity.

Using this, it is no longer necessary to allow sorting by having classes implement the Comparable interface, or writing custom Comparators for each business class.

I welcome feedback! Let me know if you think of any improvements.

--Kamilche

Code here, in filename DynamicComparer.java

import java.util.*;
import java.lang.reflect.*;

/**
 * This class will sort ArrayList or array of any Java class, on multiple fields.
 * <b>It is not required that the Java class implement Comparable.</b>
 * Instead, the comparator itself handles all the sorting logic; you 
 * simply pass in the class you wish to sort, and a sort string.
 * <p>
 * The sort string contains information about the fields to be sorted, case sensitivity,
 * and direction. It must be in the following format:
 * <p>
 *      fieldname1 [CINS] [DESC], [fieldname2 [ASC]], ...
 * <p>
 * <b>fieldname1</b> - Required; the name of the field or property name to sort by. This is case sensitive, must be spelled exactly right, and must come first.
 * <br>
 * <b>CINS</b> - If specified, sort strings case insensitively. If not specified, the default string sort is case sensitive.
 * <br>
 * <b>ASC</b> - If specified, sort data ascending (1 to 0). This isn't necessary, because if you don't specify the sort order, it defaults to ascending.
 * <br>
 * <b>DESC</b> - If specified, sort data descending (10 to 1). If not specified, the default is ascending (1 to 10).
 * <p>
 * You can specify one or more fields to sort on, each with their own direction and case sensitivity, separated by commas. 
 * <p>
 * <b>Example of use:</b>
 * <p>
 *      ArrayList<TestClass> arr = new ArrayList<TestClass>();
 * <br>
 *      // populate arr using the desired method
 * <br>
 *      DynamicComparer d = new DynamicComparer(TestClass.class, "age DESC, name CINS ASC");
 * <br>
 *      java.util.Collections.sort(arr, d);
 * <p>
 * @param Class The class of items in the array
 * @param orderBy A string containing fields to be sorted, case sensitivity, and ascending or descending order.
 * <p>
 * @author cacj235
 *
 */
@SuppressWarnings("unchecked")
public class DynamicComparer implements Comparator {
	private ArrayList<SortProperty> sortprops = null;
	private Class klazz = null;
	
	/**
	 * Perform a comparison between two objects taking into consideration multiple keys, desired sort order, and case sensitivity.
	 * @param x - First object to compare
	 * @param y - Second object to compare
     * @author cacj235
	 */
	@Override
	public int compare(Object x, Object y) {
		int retval = 0;
		Object val1, val2 = null;
		if (x == null && y == null)
			return 0;
		for (SortProperty sp : sortprops) {
			if (sp.propertyInfo != null) {
				try {
					val1 = sp.propertyInfo.get(x);
					val2 = sp.propertyInfo.get(y);
				} catch (Exception e) {
					e.printStackTrace();
					throw new RuntimeException(e.getMessage());
				}
			} else if (sp.methodInfo != null) {
				try {
					val1 = sp.methodInfo.invoke(x);
					val2 = sp.methodInfo.invoke(y);
				} catch (Exception e) {
					e.printStackTrace();
					throw new RuntimeException(e.getMessage());
				}
			}
			else {
				throw new RuntimeException("No method or property info found!");
			}
			
			if (val1 == null && val2 == null)
				return 0;
			if (x == null)
				if (sp.descending)
					return 1;
				else
					return -1;
			if (y == null)
				if (sp.descending)
					return 1;
				else
					return -1;
			if (val1 instanceof String) {
				val1 = val1.toString();
				val2 = val2.toString();
				if (sp.caseInsensitive) {
					val1 = ((String)val1).toLowerCase();
					val2 = ((String)val2).toLowerCase();
				}
			}
			retval = ((Comparable)val1).compareTo(val2);
			if (retval != 0) {
				if (sp.descending) {
					return retval * -1;
				} else {
					return retval;
				}
			}
		}
		return 0; // No differences found.
	}
	
	/**
	 * DynamicComparer constructor.
	 * <br>
	 * See class documentation 
	 * for detailed description and usage examples.
	 * @param klazz - class of items in array or list
	 * @param orderBy - string containing sort criteria.
	 * <p>
     * @author cacj235
	 */
	DynamicComparer(Class klazz, String orderBy) {	
		this.klazz = klazz;
		ArrayList<SortProperty> tmp = ParseOrderBy(orderBy);
		CheckSortProperties(tmp);
		sortprops = tmp;
	}

	/**
	 * Checks a list of sort properties, making sure the field is public, 
	 * exists in the class, and implements Comparable. 
	 * <br>
	 * If any of these aren't true, it throws a RuntimeException.
	 * @param sortprops - An ArrayList of SortProperty
	 * <p>
     * @author cacj235
	 */
	private void CheckSortProperties(ArrayList<SortProperty> sortprops) {
		// Make sure each property exists, is public, implements Comparable
		Field fi = null;
		Method mi = null;
		Class t = null;
		if (sortprops.size() == 0)
			throw new RuntimeException("No valid sort fields found!");
		for (SortProperty sProp : sortprops) {
				// Look for a field with that name
				try {
					fi = this.klazz.getField(sProp.name);
					t = fi.getType();
				} catch (SecurityException e) {
					throw new RuntimeException(String.format("Security error accessing field '%s' in class '%s'!\n", sProp.name, klazz.getSimpleName()));
				} catch (NoSuchFieldException e) {
					// Look for a method with that name
					try {
						mi = this.klazz.getMethod(sProp.name, (Class [])null);
						t = mi.getReturnType();
					} catch (SecurityException e1) {
						throw new RuntimeException(String.format("Security error accessing field '%s' in class '%s'!\n", sProp.name, klazz.getSimpleName()));
					} catch (NoSuchMethodException e1) {
						throw new RuntimeException(String.format("Field '%s' not found in class '%s'!\n", sProp.name, klazz.getSimpleName()));
					}
				}
				// Make sure it's comparable 
				if ( !(t.isPrimitive() || Comparable.class.isAssignableFrom(t)) ) {
					throw new RuntimeException(String.format("Field '%s' (%s) in class '%s' doesn't implement Comparable.\n", sProp.name, t.getName(), klazz.getSimpleName()));
				}
			if (fi != null) {
				sProp.propertyInfo = fi;
			}
			else {
				sProp.methodInfo = mi;
			}
		}
	}
	
	/**
	 * Converts a string containing sort criteria into a list of SortProperty.
	 * @param orderBy - string containing sort criteria.
	 * @return ArrayList of SortProperty.
	 * <p>
     * @author cacj235
	 */
	private ArrayList<SortProperty> ParseOrderBy(String orderBy) {
		
		if (orderBy != null) {
			orderBy = orderBy.replace("  ", " ");
			orderBy = orderBy.trim();
		}
		if (orderBy == null || orderBy.length() == 0)
			throw new IllegalArgumentException("The \"order by\" string must not be null or empty.");
		
		String[] props = orderBy.split(",");
		ArrayList<SortProperty> sortProps = new ArrayList<SortProperty>();
		String propName;
		boolean descending;
		boolean caseInsensitive;
		
		for (int i = 0; i < props.length; i++) {
			descending = false;
			caseInsensitive = false;
			propName = props[i].replace("  ", " ");
			
			for (;;) {
				int ctr = 0;
				
				propName = propName.trim();
				if (propName.toUpperCase().endsWith(" DESC")) {
					descending = true;
					propName = propName.substring(0, propName.length() - 5);
					ctr += 1;
				}
				
				propName = propName.trim();
				if (propName.toUpperCase().endsWith(" ASC")) {
					propName = propName.substring(0, propName.length() - 4);
					ctr += 1;
				}
				
				propName = propName.trim();
				if (propName.toUpperCase().endsWith(" CINS")) {
					caseInsensitive = true;
					propName = propName.substring(0, propName.length() - 5);
					ctr += 1;
				}
				
				if (ctr == 0)
					break;
			}
			
			// Add sort property to list
			sortProps.add(new SortProperty(propName, descending, caseInsensitive));
		}
		
		return sortProps;
	}
	
}

/**
 * A class used by DynamicComparer to store field level sorting information
 * <p>
 * @author cacj235
 */
class SortProperty {
	public String name;
	public boolean descending;
	public boolean caseInsensitive;
	public Field propertyInfo;
	public Method methodInfo;
	public boolean IsString;
	
	SortProperty(String propertyName, boolean sortDescending, boolean caseInsensitive) {
		if (propertyName == null || propertyName.trim().length() == 0)
			throw new IllegalArgumentException("A property cannot have an empty name.");
		this.name 				= propertyName.trim();
		this.descending 		= sortDescending;
		this.caseInsensitive 	= caseInsensitive;
	}
}

JUnit test here, in filename DynamicComparer_Test.java

import java.util.*;

import junit.framework.TestCase;

public class DynamicComparer_Test extends TestCase 
{
	ArrayList<TestClass> arr = new ArrayList<TestClass>();
	TestClass arr2[] = null;
	
	@SuppressWarnings("boxing")
	protected void setUp() {
		arr2 = new TestClass[] 
		       {
				new TestClass(1, "Cindy", 	44, "Wife", 	4.0),
				new TestClass(2, "Kevin", 	43, "Husband", 	3.0),
				new TestClass(3, "david", 	20, "Son", 		3.5),
				new TestClass(4, "Dan", 	18, "Son", 		2.0),
				new TestClass(5, "sarah", 	20, "Daughter", 2.5),
				new TestClass(6, "Sarah", 	21, "niece", 	3.5),
		       };
		for (TestClass tc : arr2)
			arr.add(tc);
	}
	
	@SuppressWarnings("boxing")
	public void testInvalidStrings() {
		// Run all the tests that should fail
		boolean failed = false;
		@SuppressWarnings("unused")
		DynamicComparer d = null;

		String[] testFalse = 
		{
			"_grade DESC",  // private field
			"id2 DESC",		// no such field 
			"",				// empty string
			null,			// null string
		};
		
		for (int i = 0; i < testFalse.length; i++)
		{
			String sortString  = testFalse[i];
			failed = false;
			
			// Create the dynamic comparer
			try {
				d = new DynamicComparer(TestClass.class, sortString);
			} catch (Exception ex) {
				failed = true;
				assertTrue(String.format("Test %d '%s' failed on creating the dynamic comparer!", i, sortString), failed);
			}			
		}
	}

	@SuppressWarnings({ "boxing", "unchecked" })
	public void testValidStringsAgainstArrayList() {
		
		boolean failed = false;
		DynamicComparer d = null;

		System.out.printf("\n%s\n------------------------------\n", "Original Order");
		for (TestClass tc : arr)
			System.out.println(tc.toString());
		
		String[][] testTrue = 
		{
			{"id", 						"1 2 3 4 5 6"}, 
			{"id DESC", 				"6 5 4 3 2 1"}, 
			{"name", 					"1 4 2 6 3 5"}, 
			{"name CINS", 				"1 4 3 2 6 5"},
			{"name CINS ASC",			"1 4 3 2 6 5"},
			{"name CINS DESC", 			"6 5 2 3 4 1"},
			{"name CINS, age", 			"1 4 3 2 5 6"},
			{"name CINS DESC, age", 	"5 6 2 3 4 1"},
			{"name CINS DESC, age DESC","6 5 2 3 4 1"},
			{"age DESC", 				"1 2 6 5 3 4"},
			{"title CINS", 				"5 2 6 3 4 1"},
			{"title CINS, name CINS",	"5 2 6 4 3 1"},
			{"getGrade DESC, age DESC, name CINS ASC", 	"1 6 3 2 5 4"},			
		};

		// Run all the tests that should complete correctly.
		for (int i = 0; i < testTrue.length; i++)
		{
			String   sortString  = testTrue[i][0];
			String[] sortOrder   = testTrue[i][1].split(" ");
			failed 				 = false;
			
			// Create the dynamic comparer
			try {
				d = new DynamicComparer(TestClass.class, sortString);
			} catch (Exception ex) {
				ex.printStackTrace();
				failed = true;
				assertFalse(String.format("Test %d '%s' failed on creating the dynamic comparer!", i, sortString), failed);
			}
			
			// Sort the array
			java.util.Collections.sort(arr, d);
			
			// Print the items in order
			System.out.printf("\n%s\n------------------------------\n", sortString);
			for (int j = 0; j < arr.size(); j++)
				System.out.printf("%s\n", arr.get(j));
			System.out.printf("\n");
			
			// Check the resulting sort order
			if (!failed) 
			{
				String actualSortOrder = "";
				for (int j = 0; j < sortOrder.length; j++)
					actualSortOrder += arr.get(j).id + " ";
				actualSortOrder = actualSortOrder.trim();
				if (!actualSortOrder.equals(testTrue[i][1])) 
				{
					failed = true;
					assertFalse(String.format("Test %d '%s' failed on resulting sort order! Should have been '%s', was '%s'", i, sortString, testTrue[i][1], actualSortOrder), failed);	
				}
			}
		}	
	}
	
	@SuppressWarnings("unchecked")
	public void test0LengthArrayList() {
		boolean 				failed 		= false;
		DynamicComparer 		d 			= null;
		ArrayList<TestClass>	arr 		= new ArrayList<TestClass>();
		String					sortString 	= "id";
		
		// Test 0 items
		try {
			d = new DynamicComparer(TestClass.class, sortString);
		} catch (Exception ex) {
			ex.printStackTrace();
			failed = true;
			assertFalse(String.format("Test '%s' failed on creating the dynamic comparer!", sortString), failed);
		}		
		
		// Sort the array
		java.util.Collections.sort(arr, d);
	}
	
	@SuppressWarnings("unchecked")
	public void test1LengthArrayList() {
		boolean 				failed 		= false;
		DynamicComparer 		d 			= null;
		ArrayList<TestClass>	arr 		= new ArrayList<TestClass>();
		String					sortString 	= "id";
		
		// Test 1 item
		arr.add(new TestClass(1, "Cindy", 	44, "Wife", 	4.0));
		try {
			d = new DynamicComparer(TestClass.class, sortString);
		} catch (Exception ex) {
			ex.printStackTrace();
			failed = true;
			assertFalse(String.format("Test '%s' failed on creating the dynamic comparer!", sortString), failed);
		}		
		
		// Sort the array
		java.util.Collections.sort(arr, d);
	}
	
	@SuppressWarnings({ "boxing", "unchecked" })
	public void testValidStringsAgainstArray() {
		
		boolean failed = false;
		DynamicComparer d = null;

		System.out.printf("\n%s\n------------------------------\n", "Original Order");
		for (TestClass tc : arr2)
			System.out.println(tc.toString());
		
		String[][] testTrue = 
		{
			{"id", 						"1 2 3 4 5 6"}, 
			{"id DESC", 				"6 5 4 3 2 1"}, 
			{"name", 					"1 4 2 6 3 5"}, 
			{"name CINS", 				"1 4 3 2 6 5"},
			{"name CINS ASC",			"1 4 3 2 6 5"},
			{"name CINS DESC", 			"6 5 2 3 4 1"},
			{"name CINS, age", 			"1 4 3 2 5 6"},
			{"name CINS DESC, age", 	"5 6 2 3 4 1"},
			{"name CINS DESC, age DESC","6 5 2 3 4 1"},
			{"age DESC", 				"1 2 6 5 3 4"},
			{"title CINS", 				"5 2 6 3 4 1"},
			{"title CINS, name CINS",	"5 2 6 4 3 1"},
			{"getGrade DESC, age DESC, name CINS ASC", 	"1 6 3 2 5 4"},			
		};

		// Run all the tests that should complete correctly.
		for (int i = 0; i < testTrue.length; i++)
		{
			String   sortString  = testTrue[i][0];
			String[] sortOrder   = testTrue[i][1].split(" ");
			failed 				 = false;
			
			// Create the dynamic comparer
			try {
				d = new DynamicComparer(TestClass.class, sortString);
			} catch (Exception ex) {
				ex.printStackTrace();
				failed = true;
				assertFalse(String.format("Test %d '%s' failed on creating the dynamic comparer!", i, sortString), failed);
			}
			
			// Sort the array
			java.util.Arrays.sort(arr2, d);
			
			// Print the items in order
			System.out.printf("\n%s\n------------------------------\n", sortString);
			for (int j = 0; j < arr2.length; j++)
				System.out.printf("%s\n", arr2[j]);
			System.out.printf("\n");
			
			// Check the resulting sort order
			if (!failed) 
			{
				String actualSortOrder = "";
				for (int j = 0; j < sortOrder.length; j++)
					actualSortOrder += arr2[j].id + " ";
				actualSortOrder = actualSortOrder.trim();
				if (!actualSortOrder.equals(testTrue[i][1])) 
				{
					failed = true;
					assertFalse(String.format("Test %d '%s' failed on resulting sort order! Should have been '%s', was '%s'", i, sortString, testTrue[i][1], actualSortOrder), failed);	
				}
			}
		}	
	}
	
	@SuppressWarnings("unchecked")
	public void test0LengthArray() {
		boolean 				failed 		= false;
		DynamicComparer 		d 			= null;
		TestClass[]             arr         = new TestClass[]{};
		String					sortString 	= "id";
		
		// Test 0 items
		try {
			d = new DynamicComparer(TestClass.class, sortString);
		} catch (Exception ex) {
			ex.printStackTrace();
			failed = true;
			assertFalse(String.format("Test '%s' failed on creating the dynamic comparer!", sortString), failed);
		}		
		
		// Sort the array
		java.util.Arrays.sort(arr, d);
	}
	
	@SuppressWarnings("unchecked")
	public void test1LengthArray() {
		boolean 				failed 		= false;
		DynamicComparer 		d 			= null;
		TestClass[]				arr 		= new TestClass[1];
		String					sortString 	= "id";
		
		// Test 1 item
		arr[0] = new TestClass(1, "Cindy", 	44, "Wife", 	4.0);
		try {
			d = new DynamicComparer(TestClass.class, sortString);
		} catch (Exception ex) {
			ex.printStackTrace();
			failed = true;
			assertFalse(String.format("Test '%s' failed on creating the dynamic comparer!", sortString), failed);
		}		
		
		// Sort the array
		java.util.Arrays.sort(arr, d);
	}
}

class TestClass // No need to implement Comparable 
{
	public int id;
	public String name;
	public Integer age;
	public String title;
	private Double _grade;
	
	public TestClass(int id, String name, Integer age, String title, Double grade) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.title = title;
		this._grade = grade;
	}
	
	public Double getGrade() {
		return _grade;
	}
	
	public void setGrade(Double value) {
		_grade = value;
	}
		
	public String toString() {
		return String.format("%d %-10s %d  %-9s %2.1f", id, name, age, title, _grade);
	}
}

[Bear Bibeault]

"Kamilche Unknown", please check your private messages for an important administrative matter.

[Wouter Oet]

Thank you for posting this. I ran 2 tests. The first gave a runtime error and the second did not really perform:

static class Test// implements Comparable<Test> 
{
	String name;
	
	public int compareTo(Test t){
		return name.compareTo(t.name);
	}
}

public static void main(String... args)
{
	Test a = new Test(), b = new Test(), c = new Test();
	a.name = "ab";
	b.name = "bc";
	c.name = "cd";
	ArrayList<Test> tests = new ArrayList();
	tests.add(c);
	tests.add(b);
	tests.add(a);
	
	long start = System.currentTimeMillis();
	DynamicComparer d = new DynamicComparer(Test.class, "name DESC");
	java.util.Collections.sort(tests, d);   
	System.out.println("Time: " + (System.currentTimeMillis() - start));
}
	   

Gave: Exception in thread "main" java.lang.RuntimeException: Field 'name' not found in class 'Test'!

static class Test implements Comparable<Test> {
	String name;
	
	public int compareTo(Test t){
		return name.compareTo(t.name);
	}
}
public static void main(String... args)
{
	Test a = new Test(), b = new Test(), c = new Test();
	a.name = "ab";
	b.name = "bc";
	c.name = "cd";
	ArrayList<Test> tests = new ArrayList();
	tests.add(c);
	tests.add(b);
	tests.add(a);
	
	long start = System.currentTimeMillis();
	DynamicComparer d = new DynamicComparer(Test.class, "name DESC");
	java.util.Collections.sort(tests, d);   
	System.out.println("Time: " + (System.currentTimeMillis() - start));
	
	tests = new ArrayList();
	tests.add(c);
	tests.add(b);
	tests.add(a);
	
	start = System.currentTimeMillis();
	java.util.Collections.sort(tests);
	System.out.println("Time: " + (System.currentTimeMillis() - start));
}    

Gave:
Time: 38
Time: 0

That is a big difference and to much in most cases.

[Cindy Carney]

Thanks for the feedback. You got that error is because the field is not public - comparators can only access public fields.

You were spot on about the speed, though! Wow, it's abysmal - 20 to 70x slower than a normal comparator. I added a 'testCapacity' routine to the JUnit tests, and discovered what you meant.

I tried some different methods, and came up with this one. It is flexible, in that it will let you sort on multiple columns with different sort criteria, like DynamicComparer... but it performs much faster, and scales well. It also allows you to access private fields.

It's still slower than a custom comparator, so if you have a need for a one off fast sort, hand coding is probably the best way to go. This routine is mainly useful for small arrays, such as you might use during web development, when you're presenting a limited result set to the user, letting them choose their sort columns, and don't want to have to hit the database every time they click the sort button.

Give this one a whirl, I think you'll like it better. My timings are below:

Standard method: Sorted 100000 items in 47 milliseconds. This is the usual Java method, where you create a new custom comparator for each sort you want.

New method: Sorted 100000 items in 172 milliseconds. This is the new method I created, which uses a single custom comparator that handles all possible sorts you might want, with per-field direction and case sensitivity.

Lazy method: Sorted 100000 items in 3437 milliseconds. This method is like 'new', but calls a pre-done compareTo proc to get you out of handing-coding the compareTo proc. The pre-done compareTo proc uses reflection to look up the fields, so while it saves you coding work, this is the slowest method.

File MultiComparable.java

package multicomparer;

abstract public interface MultiComparable 
{
	public int compareTo(Object obj2, String fieldname, boolean caseInsensitive);		
}

File MultiComparer.java

package multicomparer;

import java.lang.reflect.*;
import java.util.*;

/**
 * This class will sort ArrayList or array of any Java class, on multiple fields.
 * <br>
 * <b>It is required that the Java class implement MultiComparable, to use this comparer.</b>
 * <p>
 * The sort string contains information about the fields to be sorted, case sensitivity,
 * and direction. It must be in the following format:
 * <p>
 *      fieldname1 [CINS] [DESC], [fieldname2 [ASC]], ...
 * <p>
 * <b>fieldname1</b> - Required; the name of the field or property name to sort by. This is case sensitive, must be spelled exactly right, and must come first.
 * <br>
 * <b>CINS</b> - If specified, sort strings case insensitively. If not specified, the default string sort is case sensitive.
 * <br>
 * <b>ASC</b> - If specified, sort data ascending (1 to 0). This isn't necessary, because if you don't specify the sort order, it defaults to ascending.
 * <br>
 * <b>DESC</b> - If specified, sort data descending (10 to 1). If not specified, the default is ascending (1 to 10).
 * <p>
 * You can specify one or more fields to sort on, each with their own direction and case sensitivity, separated by commas. 
 * <p>
 * <b>Example of use:</b>
 * <p>
 *      ArrayList<TestClass> arr = new ArrayList<TestClass>();
 * <br>
 *      // populate arr using the desired method
 * <br>
 *      MultiComparer d = new MultiComparer("age DESC, name CINS ASC");
 * <br>
 *      java.util.Collections.sort(arr, d);
 * <p>
 * @param orderBy A string containing fields to be sorted, case sensitivity, and ascending or descending order.
 * <p>
 * @author cacj235
 *
 */

public class MultiComparer implements Comparator<MultiComparable>
{
	ArrayList<SortProperty> sortProps;
	
	/**
	 * Contains field-level sorting information, 
	 * for use of the 'compare' method.
	 * @author cacj235
	 *
	 */
	private class SortProperty 
	{
		public String 	name;
		public boolean 	descending;
		public boolean 	caseInsensitive;
		
		SortProperty(String propertyName, boolean sortDescending, boolean caseInsensitive) {
			if (propertyName == null)
				throw new IllegalArgumentException("A property cannot be null.");
			propertyName = propertyName.trim();
			if (propertyName.length() == 0)
				throw new IllegalArgumentException("A property cannot have an empty name.");
			this.name 				= propertyName.intern();
			this.descending 		= sortDescending;
			this.caseInsensitive 	= caseInsensitive;
		}
	}
	
	/**
	 * MultiComparer constructor.
	 * <br>
	 * Converts a string containing sort criteria into a list of SortProperty,
	 * and stores it for future use of the 'compare' method.
	 * @param orderBy - string containing sort criteria.
	 * <p>
     * @author cacj235
	 */
	public MultiComparer(String orderBy)
	{	
		if (orderBy != null) {
			orderBy = orderBy.replace("  ", " ");
			orderBy = orderBy.trim();
		}
		if (orderBy == null || orderBy.length() == 0)
			throw new IllegalArgumentException("The \"order by\" string must not be null or empty.");
		
		String[] props = orderBy.split(",");
		ArrayList<SortProperty> sortProps = new ArrayList<SortProperty>();
		String propName;
		boolean descending;
		boolean caseInsensitive;
		
		for (int i = 0; i < props.length; i++) {
			descending = false;
			caseInsensitive = false;
			propName = props[i].replace("  ", " ");
			
			for (;;) {
				int ctr = 0;
				
				propName = propName.trim();
				if (propName.toUpperCase().endsWith(" DESC")) {
					descending = true;
					propName = propName.substring(0, propName.length() - 5);
					ctr += 1;
				}
				
				propName = propName.trim();
				if (propName.toUpperCase().endsWith(" ASC")) {
					propName = propName.substring(0, propName.length() - 4);
					ctr += 1;
				}
				
				propName = propName.trim();
				if (propName.toUpperCase().endsWith(" CINS")) {
					caseInsensitive = true;
					propName = propName.substring(0, propName.length() - 5);
					ctr += 1;
				}
				
				if (ctr == 0)
					break;
			}
			
			// Add sort property to list
			sortProps.add(new SortProperty(propName, descending, caseInsensitive));
		}
		
		this.sortProps = sortProps;
	}
	
	/**
	 * Perform a comparison between two objects taking into consideration multiple keys, desired sort order, and case sensitivity.
	 * @param obj1 - First object to compare
	 * @param obj2 - Second object to compare
     * @author cacj235
	 */
	public int compare(MultiComparable obj1, MultiComparable obj2) 
	{
		for (SortProperty sp : sortProps)
		{
			int value = obj1.compareTo(obj2, sp.name, sp.caseInsensitive);
			if (value != 0)
			{
				if (sp.descending)
					value *= -1;
				return value;
			}
		}
		return 0;
	}
	
	/**
	 * Call this method if you're too lazy to implement compareTo,
	 * but beware, you will pay the price in slow performance!
	 * @param obj1
	 * @param obj2
	 * @param fieldname
	 * @param caseInsensitive
	 * @return int containing compareTo value
	 */
	@SuppressWarnings("unchecked")
	public static int compareTo(Object obj1, Object obj2, String fieldname, boolean caseInsensitive) 
	{
		Comparable value1 = GetInstanceValue(obj1, fieldname);
		Comparable value2 = GetInstanceValue(obj2, fieldname);
		
		if (value1 == null && value2 == null)
			return 0;
		
		if (value1 == null)
			return -1;
		
		if (value2 == null)
			return 1;		

		if (caseInsensitive && (value1 instanceof String))
			return (((String)value1).compareToIgnoreCase((String)value2));
		
		return (value1.compareTo(value2));
	}
	
	@SuppressWarnings("unchecked")
	private static Comparable GetInstanceValue(Object obj, String fieldname)
	{
		Exception ex = null;
		try {
			Field fieldInfo = obj.getClass().getField(fieldname);
			return (Comparable) fieldInfo.get(obj);
		} catch (NoSuchFieldException e) {
			ex = e;
			try {
				Method methodInfo = obj.getClass().getMethod(fieldname, (Class[])null);
				return (Comparable) methodInfo.invoke(obj, (Object[])null);
			} catch (Exception e1) {} 
		} catch (Exception e) {
			ex = e;
		}
		throw new RuntimeException(String.format("Error when accessing field %s - %s", fieldname, ex.getMessage()));
	}

}

File TestClass.java

import multicomparer.*;

public class TestClass implements MultiComparable 
{
	public int id;
	public String name;
	public Integer age;
	public String title;
	private Double _grade;
	public static boolean SortSlow = false;
	
	public TestClass(int id, String name, Integer age, String title, Double grade) {
		this.id = id;
		this.name = name;
		this.age = age;
		this.title = title;
		this._grade = grade;
	}
	
	public Double getGrade() {
		return _grade;
	}
	
	public void setGrade(Double value) {
		_grade = value;
	}
		
	@SuppressWarnings("boxing")
	public String toString() {
		return String.format("%d %-10s %d  %-9s %2.1f", id, name, age, title, _grade);
	}

	/**
	 * 
	 * Compare a given field on this object, to another object.
	 * Note that you CAN <b>wimp out</b>, 
	 * and tell the MultiComparer.compareTo
	 * to look it up and return the value. 
	 * If you choose this method,
	 * know that MultiComparer.compareTo uses reflection to
	 * obtain the value of the field, which can be quite slow.
	 * You won't want to do this unless you're sorting small arrays,
	 * under 10,000 entries or so.
	 * <p>
	 * For <b>maximum performance</b>, it's best to implement it 
	 * fully, being sure to handle
     * all the fields you might need to sort on.
	 */
	@Override
	public int compareTo(Object obj2, String fieldname, boolean caseInsensitive) 
	{
		if (SortSlow)
			return MultiComparer.compareTo(this, obj2, fieldname, caseInsensitive); // the wimpy method.
			
		int value = 0;
		TestClass test1 = this;
		TestClass test2 = (TestClass) obj2;
		
		if (fieldname.equals("id"))
			value = test1.id - test2.id; 
		else if (fieldname.equals("name"))
			if (caseInsensitive)
				value = test1.name.compareToIgnoreCase(test2.name); 
			else
				value = test1.name.compareTo(test2.name); 
		else if (fieldname.equals("age"))
			value = test1.age.compareTo(test2.age); 
		else if (fieldname.equals("title"))
			if (caseInsensitive)
				value = test1.title.compareToIgnoreCase(test2.title); 
			else
				value = test1.title.compareTo(test2.title); 
		else if (fieldname.equals("getGrade"))
			// You could do it this way, using a getter...
			//    value = test1.getGrade().compareTo(test2.getGrade()); 
		    // Or you could access the private field directly.
			value = test1._grade.compareTo(test2._grade); 
		else	
			// Unhandled sort field.
			// You could bomb, but you might want to pass the buck,
			// which look it up via reflection instead.
			return MultiComparer.compareTo(this, obj2, fieldname, caseInsensitive);

		return value;
	}
}

File MultiComparable_Test.java

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Random;

import multicomparer.MultiComparer;
import junit.framework.TestCase;

public class MultiComparable_Test extends TestCase 
{
	ArrayList<TestClass> arr = new ArrayList<TestClass>();
	TestClass arr2[] = null;
	int max = 100000;
	
	@SuppressWarnings("boxing")
	protected void setUp() {
		arr2 = new TestClass[] 
		       {
				new TestClass(1, "Cindy", 	44, "Wife", 	4.0),
				new TestClass(2, "Kevin", 	43, "Husband", 	3.0),
				new TestClass(3, "david", 	20, "Son", 		3.5),
				new TestClass(4, "Dan", 	18, "Son", 		2.0),
				new TestClass(5, "sarah", 	20, "Daughter", 2.5),
				new TestClass(6, "Sarah", 	21, "niece", 	3.5),
		       };
		for (TestClass tc : arr2)
			arr.add(tc);
	}
	
	@SuppressWarnings("boxing")
	private ArrayList<TestClass>GetRandomData() {
		// Set up the data
		ArrayList<TestClass> arr = new ArrayList<TestClass>();
		Random rnd = new Random(0);
		int index;
		for (int i = 0; i < max; i++) {
			index = (int)(rnd.nextDouble() * 10);
			TestClass tc = new TestClass(i, String.format("Name %d", index), index, "title", rnd.nextDouble()*4);
			arr.add(tc);
		}
		return arr;
	}

	@SuppressWarnings("boxing")
	public void testInvalidStrings() {
		// Run all the tests that should fail
		boolean failed = false;
		@SuppressWarnings("unused")
		MultiComparer d = null;

		String[] testFalse = 
		{
			"",				// empty string
			null,			// null string
		};
		
		for (int i = 0; i < testFalse.length; i++)
		{
			String sortString  = testFalse[i];
			failed = false;
			
			// Create the dynamic comparer
			try {
				d = new MultiComparer(sortString);
			} catch (Exception ex) {
				failed = true;
				assertTrue(String.format("Test %d '%s' failed on creating the dynamic comparer!", i, sortString), failed);
			}			
		}
	}

	@SuppressWarnings({ "boxing" })
	public void testValidStringsAgainstArrayList() {
		
		boolean failed = false;
		MultiComparer d = null;

		System.out.printf("\n%s\n------------------------------\n", "Original Order");
		for (TestClass tc : arr)
			System.out.println(tc.toString());
		
		String[][] testTrue = 
		{
			{"id", 						"1 2 3 4 5 6"}, 
			{"id DESC", 				"6 5 4 3 2 1"}, 
			{"name", 					"1 4 2 6 3 5"}, 
			{"name CINS", 				"1 4 3 2 6 5"},
			{"name CINS ASC",			"1 4 3 2 6 5"},
			{"name CINS DESC", 			"6 5 2 3 4 1"},
			{"name CINS, age", 			"1 4 3 2 5 6"},
			{"name CINS DESC, age", 	"5 6 2 3 4 1"},
			{"name CINS DESC, age DESC","6 5 2 3 4 1"},
			{"age DESC", 				"1 2 6 5 3 4"},
			{"title CINS", 				"5 2 6 3 4 1"},
			{"title CINS, name CINS",	"5 2 6 4 3 1"},
			{"getGrade DESC, age DESC, name CINS ASC", 	"1 6 3 2 5 4"},			
		};

		// Run all the tests that should complete correctly.
		for (int i = 0; i < testTrue.length; i++)
		{
			String   sortString  = testTrue[i][0];
			String[] sortOrder   = testTrue[i][1].split(" ");
			failed 				 = false;
			
			// Create the dynamic comparer
			try {
				d = new MultiComparer(sortString);
			} catch (Exception ex) {
				ex.printStackTrace();
				failed = true;
				assertFalse(String.format("Test %d '%s' failed on creating the dynamic comparer!", i, sortString), failed);
			}
			
			// Sort the array
			java.util.Collections.sort(arr, d);
			
			// Print the items in order
			System.out.printf("\n%s\n------------------------------\n", sortString);
			for (int j = 0; j < arr.size(); j++)
				System.out.printf("%s\n", arr.get(j));
			System.out.printf("\n");
			
			// Check the resulting sort order
			if (!failed) 
			{
				String actualSortOrder = "";
				for (int j = 0; j < sortOrder.length; j++)
					actualSortOrder += arr.get(j).id + " ";
				actualSortOrder = actualSortOrder.trim();
				if (!actualSortOrder.equals(testTrue[i][1])) 
				{
					failed = true;
					assertFalse(String.format("Test %d '%s' failed on resulting sort order! Should have been '%s', was '%s'", i, sortString, testTrue[i][1], actualSortOrder), failed);	
				}
			}
		}	
	}
	
	public void test0LengthArrayList() {
		boolean 				failed 		= false;
		MultiComparer 			d 			= null;
		ArrayList<TestClass>	arr 		= new ArrayList<TestClass>();
		String					sortString 	= "id";
		
		// Test 0 items
		try {
			d = new MultiComparer(sortString);
		} catch (Exception ex) {
			ex.printStackTrace();
			failed = true;
			assertFalse(String.format("Test '%s' failed on creating the dynamic comparer!", sortString), failed);
		}		
		
		// Sort the array
		java.util.Collections.sort(arr, d);
	}
	
	@SuppressWarnings("boxing")
	public void test1LengthArrayList() {
		boolean 				failed 		= false;
		MultiComparer 			d 			= null;
		ArrayList<TestClass>	arr 		= new ArrayList<TestClass>();
		String					sortString 	= "id";
		
		// Test 1 item
		arr.add(new TestClass(1, "Cindy", 	44, "Wife", 	4.0));
		try {
			d = new MultiComparer(sortString);
		} catch (Exception ex) {
			ex.printStackTrace();
			failed = true;
			assertFalse(String.format("Test '%s' failed on creating the dynamic comparer!", sortString), failed);
		}		
		
		// Sort the array
		java.util.Collections.sort(arr, d);
	}
	
	@SuppressWarnings({ "boxing" })
	public void testValidStringsAgainstArray() {
		
		boolean failed = false;
		MultiComparer d = null;

		System.out.printf("\n%s\n------------------------------\n", "Original Order");
		for (TestClass tc : arr2)
			System.out.println(tc.toString());
		
		String[][] testTrue = 
		{
			{"id", 						"1 2 3 4 5 6"}, 
			{"id DESC", 				"6 5 4 3 2 1"}, 
			{"name", 					"1 4 2 6 3 5"}, 
			{"name CINS", 				"1 4 3 2 6 5"},
			{"name CINS ASC",			"1 4 3 2 6 5"},
			{"name CINS DESC", 			"6 5 2 3 4 1"},
			{"name CINS, age", 			"1 4 3 2 5 6"},
			{"name CINS DESC, age", 	"5 6 2 3 4 1"},
			{"name CINS DESC, age DESC","6 5 2 3 4 1"},
			{"age DESC", 				"1 2 6 5 3 4"},
			{"title CINS", 				"5 2 6 3 4 1"},
			{"title CINS, name CINS",	"5 2 6 4 3 1"},
			{"getGrade DESC, age DESC, name CINS ASC", 	"1 6 3 2 5 4"},			
		};

		// Run all the tests that should complete correctly.
		for (int i = 0; i < testTrue.length; i++)
		{
			String   sortString  = testTrue[i][0];
			String[] sortOrder   = testTrue[i][1].split(" ");
			failed 				 = false;
			
			// Create the dynamic comparer
			try {
				d = new MultiComparer(sortString);
			} catch (Exception ex) {
				ex.printStackTrace();
				failed = true;
				assertFalse(String.format("Test %d '%s' failed on creating the dynamic comparer!", i, sortString), failed);
			}
			
			// Sort the array
			java.util.Arrays.sort(arr2, d);
			
			// Print the items in order
			System.out.printf("\n%s\n------------------------------\n", sortString);
			for (int j = 0; j < arr2.length; j++)
				System.out.printf("%s\n", arr2[j]);
			System.out.printf("\n");
			
			// Check the resulting sort order
			if (!failed) 
			{
				String actualSortOrder = "";
				for (int j = 0; j < sortOrder.length; j++)
					actualSortOrder += arr2[j].id + " ";
				actualSortOrder = actualSortOrder.trim();
				if (!actualSortOrder.equals(testTrue[i][1])) 
				{
					failed = true;
					assertFalse(String.format("Test %d '%s' failed on resulting sort order! Should have been '%s', was '%s'", i, sortString, testTrue[i][1], actualSortOrder), failed);	
				}
			}
		}	
	}
	
	public void test0LengthArray() {
		boolean 				failed 		= false;
		MultiComparer	 		d 			= null;
		TestClass[]             arr         = new TestClass[]{};
		String					sortString 	= "id";
		
		// Test 0 items
		try {
			d = new MultiComparer(sortString);
		} catch (Exception ex) {
			ex.printStackTrace();
			failed = true;
			assertFalse(String.format("Test '%s' failed on creating the dynamic comparer!", sortString), failed);
		}		
		
		// Sort the array
		java.util.Arrays.sort(arr, d);
	}
	
	@SuppressWarnings("boxing")
	public void test1LengthArray() {
		boolean 				failed 		= false;
		MultiComparer	 		d 			= null;
		TestClass[]				arr 		= new TestClass[1];
		String					sortString 	= "id";
		
		// Test 1 item
		arr[0] = new TestClass(1, "Cindy", 	44, "Wife", 	4.0);
		try {
			d = new MultiComparer(sortString);
		} catch (Exception ex) {
			ex.printStackTrace();
			failed = true;
			assertFalse(String.format("Test '%s' failed on creating the dynamic comparer!", sortString), failed);
		}		
		
		// Sort the array
		java.util.Arrays.sort(arr, d);
	}
	
	@SuppressWarnings({ "boxing", "unchecked" })
	public void testSpeedOld() {
		
		class NormalComparator implements Comparator {
			  public int compare(Object obj1, Object obj2) {
			    TestClass test1 = (TestClass) obj1;
			    TestClass test2 = (TestClass) obj2;
			    if (test1.age.equals(test2.age))
			    	return test1.id - test2.id;
			    else
			    	return test1.age.compareTo(test2.age);
			  }
		}

		Comparator		 		d			= new NormalComparator();
		ArrayList<TestClass> 	arr 		= GetRandomData();
		long					starttime	= 0;

		// Time the old way
		System.gc();
		starttime = System.currentTimeMillis();
		java.util.Collections.sort(arr, d);
		System.out.printf("Old  method: Sorted %d items in %d milliseconds.\n", max, System.currentTimeMillis() - starttime);
	}

	@SuppressWarnings({ "boxing" })
	public void testSpeedNew() {
		String					sortString 	= "age, id";
		MultiComparer 			d			= new MultiComparer(sortString);
		ArrayList<TestClass> 	arr 		= GetRandomData();
		long					starttime	= 0;

		System.gc();
		// Time the new way
		starttime = System.currentTimeMillis();
		java.util.Collections.sort(arr, d);
		System.out.printf("New  method: Sorted %d items in %d milliseconds.\n", max, System.currentTimeMillis() - starttime);
	}
		
	@SuppressWarnings({ "boxing" })
	public void testSpeedNewLazy() {
		String					sortString 	= "age, id";
		MultiComparer 			d			= new MultiComparer(sortString);
		ArrayList<TestClass> 	arr 		= GetRandomData();
		long					starttime	= 0;

		System.gc();
		// Time the new way, without using the custom sort method
		TestClass.SortSlow = true;
		starttime = System.currentTimeMillis();
		java.util.Collections.sort(arr, d);
		System.out.printf("Lazy method: Sorted %d items in %d milliseconds.\n", max, System.currentTimeMillis() - starttime);
	}

}