Sorting the unsortable

You will have to forgive this blog entry as most of you will know this tip, but it was years since I last used it and when I wanted it last night it completely went out of my head, so I’m putting it up here as an aide memoire

So here is the problem, you have a java collection (in this case a List) containing java custom classes.


and here is the Address class that this is a List of:

package com.ldc.classes;
public class Address {
    private String firstLine;
    private String secondLine;
    private String postCode;
    private int ownerId;
    public String getFirstLine() {
        return firstLine;
    public void setFirstLine(String firstLine) {
        this.firstLine = firstLine;
    public String getSecondLine() {
        return secondLine;
    public void setSecondLine(String secondLine) {
        this.secondLine = secondLine;
    public String getPostCode() {
        return postCode;
    public void setPostCode(String postCode) {
        this.postCode = postCode;
    public int getOwnerId() {
        return ownerId;
    public void setOwnerId(int ownerId) {
        this.ownerId = ownerId;

OK, You have got this List of Classes from something that the user has done, and you present them with this List, they then go “cant it be sorted by the Age of the person who lives there” , “errr well not really as the Address class does not contain the residents age, that is in a different class.

package com.ldc.classes;
public class Person {
    private int personId;
    private String firstName;
    private String lastName;
    private int age;  

“well just sort it out cant you”……..ffffssssss

Now I expect that most of you are thinking that it would be easier to do this with a SQL statement but believe me there are times when you cant or don’t want to do that, so we have to figure out a way or glue the 2 classes together and making them sortable, we are going to do that with a third class, and one that has a bit of magic in it called “implements Comparable”, our special class need to have the list of address in that we want to sort and something we want to sort them BY (in this case ownerID).

package com.ldc.classes;
public class SortableAddress implements Comparable<SortableAddress> {
    private Address address;
    private int ownerAge;
    public Address getAddress() {
        return address;
    public void setAddress(Address address) {
        this.address = address;
    public int getOwnerAge() {
        return ownerAge;
    public void setOwnerAge(int ownerAge) {
        this.ownerAge = ownerAge;
    public int compareTo(SortableAddress compareForm) {
        int compareAge = ((SortableAddress) compareForm).getOwnerAge(); 
        return this.ownerAge - compareAge;

You can see that this class has 2 special bits in it, the first is the “implements Comparable” at the top and the second is the “CompareTo” at the bottom which I have tried to make as simple as possible so you can just swap out your values and get it working on your classes. what this means is you can now use, the standard Collection.sort that you would normally use to sort a list, but use it on your class, here is an example implementing that:

package com.ldc;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import com.ldc.classes.Address;
import com.ldc.classes.SortableAddress;
public class SortMyClass {
    // OK we have a unsorted list of addresses and we are going to pass them to the function "getasortedListofAddress"
    public List<Address> getasortedListofAddress(
            List<Address> unsortedAddressList) {
        //first lets make a empty sortable address list (our special class)        
        List<SortableAddress> sortableAddressList = new ArrayList<SortableAddress>();
        //and loop though the unsorted list of addresses adding each on to the special class
        for (Address tempAddress : unsortedAddressList) {
            SortableAddress sortableAddress = new SortableAddress();
            //here we are getting the owners age which is the value we will be sorting by, to the special class
        //we now have a fully populated class that can be sorted using the standard Collections.sort
        //hey presto we have sorted the list
        //now just run though the special class, to move the Address back into their old format, but now they are ordered!!!
        List<Address> listOfSortedAddressToReturn = new ArrayList<Address>();
        for (SortableAddress tempAddress : sortableAddressList) {
        return listOfSortedAddressToReturn;
    private int getTheOwnersAge(int ownersID) {
        // some code that gets the owners age from its ID
        int ownersAge = 24;
        return ownersAge;

give me a kick if you want me to explain it in more detail, but that that should be enough to provide a practical solution to most of you (and me when I next need it)

Old Comments
##### Mark(23/05/2012 14:43:57 GDT)
Oh, I agree generic would be best in real life, I was trying to do the easiest example to follow, but Dear readers Kerr is right when you actually put this bugger into practice
##### Kerr Rainey(23/05/2012 14:24:05 GDT)
I’d try to make this a little more generic by replacing int ownerAge (and associated getters/setters) with Comparable comparable.

Then you push down what it is that the SortableAddress is comparing. Since Integer is Comparable and we have auto boxing, this would be a drop in replacement for what you already have, bar the refactoring of the getter/setter names.

Leave a Reply

Your email address will not be published.