Sort by arbitrary value of object inside Map

Question

I have a HashMap full of user objects, let's say. I want to sort the user objects in different ways. So if the user object contains name, age, height, weight, etc., I need to sort on any one of those at runtime.
I've seen some example in the forums for sorting a HashMap by value (involves creating a new structure, which is fine), but I guess I need to write a comparator that digs INTO the objects and compares based on properties INSIDE the object. Is this simple to do? Any elegant solution for this? I'm sure I could brute force hack this, but I wanted to use Colleciton and Comparator if at all possible.

Answer 1

Example without any 3rd party libraries (but please do):import java.beans.BeanInfo;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test {
    // don't use this, use something like BeanUtils
    // this just serves as a quick example
    private static Object getProperty(Object bean, String propertyName) {
        Object property = null;
        try {
            BeanInfo beanInfo = Introspector.getBeanInfo (bean.getClass ());
            PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors ();
            for (PropertyDescriptor propertyDescriptor: propertyDescriptors) {
                if (propertyDescriptor.getName ().equals (propertyName)) {
                    property = propertyDescriptor.getReadMethod ().invoke (bean);
                    break;
        } catch (Exception exception) {}
        return property;
    public static class PropertyComparator<T> implements Comparator<T> {
        private String propertyName;
        public PropertyComparator (String propertyName) {
            this.propertyName = propertyName;
        public int compare (T a, T b) {
            Object valueA = getProperty (a, propertyName);
            Object valueB = getProperty (b, propertyName);
            // yet again - quite dirty [and not production ready :)], since null isn't instanceof anything
            if (! (valueA instanceof Comparable) || ! (valueB instanceof Comparable)) {
                throw new IllegalStateException ();
            return ((Comparable) valueA).compareTo (valueB);
    public static void main (String... parameters) {
        List<Person> queen = new ArrayList<Person> ();
        queen.add (new Person ("Freddie", "Mercury"));
        queen.add (new Person ("Brian", "May"));
        queen.add (new Person ("John", "Deacon"));
        queen.add (new Person ("Roger", "Taylor"));
        System.out.println (queen);
        Collections.sort (queen, new PropertyComparator<Person> ("firstName"));
        System.out.println (queen);
        Collections.sort (queen, new PropertyComparator<Person> ("lastName"));
        System.out.println (queen);       
    private static class Person {
        private String firstName;
        private String lastName;
        public Person (String firstName, String lastName) {
            this.firstName = firstName;
            this.lastName = lastName;
        public String getFirstName () {
            return firstName;
        public String getLastName () {
            return lastName;
        @Override
        public String toString () {
            return String.format ("%s %s", firstName, lastName);
}(This sorts a list, not a map. I'm sure you'll be able to adapt it to your situation.)