Sorting ArrayList of MemberBean objects

[Rahul Pandey]

Hi,

I have an ArrayList which contains MemberBean objects. The MemberBean is displayed in the JSP as a table with four fields - First Name, Last Name, Member ID (integer) and User Name.

I need to sort this based on user selected field and in either ascending or descending order.

I know I can use the Comparator interface with the Collections.sort(List,Comparator) but somehow I am not getting around to making a generic Comparator which will sort based on any input field.

Can anyone help me with this?

Thanks in advance!

[Campbell Ritchie]

Welcome to the Ranch.
You will have to go through the API and find Comparator and set up four classes which implement Comparator. Set up each of the methods as a compareTo() method. You can simply use

return a.getFirstName().compareto(b.getFirstName());

because Strings already implement the Comparable interface.
For ID numbers you can get away with something like

return a.getId() - b.getID();

Note that you will have to fulfil the requirements in the API specifications for Comparator.

To sort backwards, try the reverse method of Collections.

CR

[Rahul Pandey]

Thanks CR!

[Rahul Pandey]

This is how my final implementation looks like..

The function sortMemberList is placed in a common Util class and called from wherever the sorting needs to be done.
--------------------------

public static void sortMemberList(ArrayList memberList, String orderBy, String ascDescIndicator){
if("firstName".equals(orderBy)){
Collections.sort(memberList, FirstNameComparator);
} else if("lastName".equals(orderBy)){
Collections.sort(memberList, LastNameComparator);
} else if("loginId".equals(orderBy)){
Collections.sort(memberList, LoginIdComparator);
} else if("policyNumber".equals(orderBy)){
Collections.sort(memberList, CardholderIDComparator);
}

if("desc".equals(ascDescIndicator)){
Collections.reverse(memberList);
}

}

----------------------------

To avoid making four different classes, I incorporated all the custom comparator classes into the Util class itself as inner-classes. It really simplifies your code structure.

----------------------------

public static Comparator LastNameComparator = new Comparator() {
    public int compare(Object member, Object anotherMember) {
      String lastName1 = ((Member) member).getLastName().toUpperCase();
      String lastName2 = ((Member) anotherMember).getLastName().toUpperCase();
        return lastName1.compareTo(lastName2);
      
    }
  };
 
public static Comparator FirstNameComparator = new Comparator() {
    public int compare(Object member, Object anotherMember) {
      String firstName1 = ((Member) member).getFirstName().toUpperCase();
      String firstName2 = ((Member) anotherMember).getFirstName().toUpperCase();
        return firstName1.compareTo(firstName2);
 
    }
  };
  
public static Comparator LoginIdComparator = new Comparator() {
    public int compare(Object member, Object anotherMember) {
      String loginId1 = ((Member) member).getLoginId().toUpperCase();
      String loginId2 = ((Member) member).getLoginId().toUpperCase();
 
    return loginId1.compareTo(loginId2);
      
    }
  };

-----------------------------

And finally, from my implementation class, this is how I called the sort functionality...

-----------------------------

Util.sortMemberList(memberList, orderBy, ascDescIndicator);

-----------------------------

That's it! Its really quite simple when you think about it!!

[steve souza]

Another interesting more generic solution to this problem would be to implement a Comparator using Reflection. I have used psuedo code to do this below.

 
 
public class ReflectionComparator implements Comparator {
 
private String methodName;
public ReflectionComparator (String methodName) {
   this.methodName=methodName;
}
 
public int compare(Object obj1, Object obj2) {
 
  Object obj1ReturnVal=(call methodName on obj1);
  Object obj2ReturnVal=(call methodName on obj2);
 
  if (obj1ReturnVal!=null && obj1ReturnValue instanceof Comparable)
    return obj1ReturnVal.compareTo(obj2ReturnVal);
  else
    throw RuntimeException("could be improved here");
}
  
 

 
}
 

Then you could use the code in the following manner.

   
List list=...populate with your instances... 
 
Collections.sort(list, new ReflectionComparator("getFirstName"));
Collections.sort(list, new ReflectionComparator("getLastName"));
Collections.sort(list, new ReflectionComparator("getMemberID"));
Collections.sort(list, new ReflectionComparator("getUserName"));
 
//You could also add an overloaded constructor to take in sort order
Collections.sort(list, new ReflectionComparator("getFirstName", "asc"));
Collections.sort(list, new ReflectionComparator("getFirstName", "desc"));
 
// You could even overload the constructor to take an array of method names
// The following would be the equivalent of order by getLastName desc, getFirstName asc
String[][] orderByClause={{"getLastName","desc"},{"getFirstName", "asc"}};
Collections.sort(list, new ReflectionComparator(orderByClause));
 

Also a cool open source project is josql that allows you to query collections in a declaritive way (something like 'select * from collection order by getLastName() desc, getFirstName() asc'): http://josql.sourceforge.net/

My FormattedDataSet API has the ability to use a sql like syntax on Object[][]. You can query by name or position. An example of using ArraySQL to query by position follows:

   
import com.fdsapi.arrays.*;
 
Object[][] data=...;
ArraySQL asql=new ArraySQL("select * from array order by col0 desc, col1 asc");
data=asql.execute(data);
 
 

[steve souza]

Here is a reflective version I found on google, but with getName hard coded.

 
 
   /**
     * Compares any object that has a "getName()" method that returns a String
     */
    public static class ReflectiveNameComparator implements Comparator {
public int compare(Object o1, Object o2) {
    try {
Method m1 = o1.getClass().getMethod("getName", new Class[] {});
Method m2 = o2.getClass().getMethod("getName", new Class[] {});
return ((String) m1.invoke(o1, new Object[] {})).compareTo((String) m2.invoke(o2, new Object[] {}));
    } catch (Exception ex) {
throw new RuntimeException("boo-hoo", ex);
    }
}
    }
 

[Rahul Pandey]

Ahh! Just the perfect generic solution I was looking for!!

Thanks a ton, Steve and CR!

[steve souza]

Post the code that you come up with. I would like to see and comment on the end result. I should also say your original solution was good too.

[steve souza]

I cleaned up the code from my postings above. I still didn't compile it however. If you test it or modify it and it works, let me know. That code could be handy...

    
 
 
   /**
     * Compares any object that has a "getName()" method that returns a String
     */
 
import java.io.*;
 
 
    public class ReflectionComparator implements Comparator, Serializable {
 
       private static final Class[] NO_ARGS=null; 
       private static final Object[] NO_ARG_VALUES=null; 
 
       private String methodName;
       public ReflectionComparator (String methodName) {
         this.methodName=methodName;
       }
   
 
public int compare(Object o1, Object o2) {
    try {
 
Object obj1ReturnVal = o1.getClass().getMethod(methodName, NO_ARGS).invoke(o1, NO_ARG_VALUES));
Object obj2ReturnVal = o2.getClass().getMethod(methodName, NO_ARGS).invoke(o2, NO_ARG_VALUES);
 
 
                if (obj1ReturnVal!=null && obj1ReturnValue instanceof Comparable)
                  return obj1ReturnVal.compareTo(obj2ReturnVal);
                else
                  throw new Exception("This object does not implement Comparable or it is null: "+o1);
 
    } catch (Exception ex) {
throw new RuntimeException("Exception occurred in Comparator: object1="+o1+", object2="+o2, ex);
    }
}
 
    }
 

[ February 22, 2007: Message edited by: steve souza ]

[steve souza]

you may also familiarize yourself with these useful comparators:

http://jakarta.apache.org/commons/collections/api-release/org/apache/commons/collections/comparators/package-summary.html

[Rahul Pandey]

steve, here's my final version...this worked beautifully...though the code posted by you above also works just as well:

first the reflection comparator class..

    
public class ReflectionComparator implements Comparator {
private String methodName;
 
public ReflectionComparator(String methodName) {
this.methodName = methodName;
}
 
public int compare(Object o1, Object o2) { 

try {
Method m1 = o1.getClass().getMethod(methodName, new Class[] {});
Method m2 = o2.getClass().getMethod(methodName, new Class[] {});
return ((String) m1.invoke(o1, new Object[] {})).compareTo((String) m2.invoke(o2, new Object[] {}));    
} catch (Exception ex) {
throw new RuntimeException("boo-hoo", ex);    
}



}
}

then the sortlist function...

   
 
public static void sortList(ArrayList mbrList, String sortField, boolean ascending){
if("FirstName".equals(sortField)){
Collections.sort(mbrList, new ReflectionComparator("getFirstName"));
} else if("LastName".equals(sortField)){
Collections.sort(mbrList, new ReflectionComparator("getLastName"));
} else if("UserName".equals(sortField)){
Collections.sort(mbrList, new ReflectionComparator("getUserName"));
} else if("CardHolderId".equals(sortField)){
Collections.sort(mbrList, new ReflectionComparator("getCardHolderId"));
}
if(!ascending){
Collections.reverse(mbrList);
}

}

finally, the function call to sort the list by First Name...

    
 
sortList(mbrList, "FirstName", true);

thanks for all the help...the link was useful too!

[jay lai]

Rahul:

I need to sort 2 columns out of 4 columns retrieve from database.


To look into your code, try to understand what are "FirstName", "LastName", where exactly this reference to? Thanks

public static void sortList(ArrayList mbrList, String sortField, boolean ascending){
if("FirstName".equals(sortField)){
Collections.sort(mbrList, new ReflectionComparator("getFirstName"));
} else if("LastName".equals(sortField)){
Collections.sort(mbrList, new ReflectionComparator("getLastName"));
} else if("UserName".equals(sortField)){
Collections.sort(mbrList, new ReflectionComparator("getUserName"));
} else if("CardHolderId".equals(sortField)){
Collections.sort(mbrList, new ReflectionComparator("getCardHolderId"));
}
if(!ascending){
Collections.reverse(mbrList);
}

}

[steve souza]

A solution like this does exactly what you are requesting.

  // You could even overload the constructor to take an array of method names
// The following would be the equivalent of order by getLastName desc, getFirstName asc
String[][] orderByClause={{"getLastName","desc"},{"getFirstName", "asc"}};
Collections.sort(list, new ReflectionComparator(orderByClause));

[jay lai]

Can you elaborate on this? Do I have to re-write the method compare? I did what you recommended, but it is not throwing exception.

Many thanks in advance