Alphabetically Sort a Java Collection based upon the 'toString' value of its member items

Question

Assume I have a user defined Java class called Foo such as:

public class Foo 
{

    private String aField;

    @Override
    public String toString()
    {
        return aField;
    }

}

And a Collection such as:

List<Foo> aList;

What I am looking to do is to sort the List alphabetically based upon each member's returned '.toString()' value.

I have tried using the Collections.sort() method, but the result was not what I was attempting. What do I need to do inorder to accomplish this?

Answer 1

Collections.sort(fooList,
                 new Comparator<Foo>()
                 {
                     public int compare(Foo f1, Foo f2)
                     {
                         return f1.toString().compareTo(f2.toString());
                     }        
                 });

Assuming that toString never returns null and that there are no null items in the list.

Answer 2

google-collections makes this really easy with Ordering:

Collections.sort(list, Ordering.usingToString());

Is bringing in a whole 3rd-party library just to use something you could write trivially using a Comparator (as others have provided) worthwhile? No, but google-collections is so cool you'll want to have it anyway for a bunch of other reasons.

On the sorting front, you can also easily do things like reversing:

Ordering.usingToString().reverse();

or break ties:

Ordering.usingToString().compound(someOtherComparator);

or deal with nulls:

Ordering.usingToString().nullsFirst();

etc., but there's a bunch more stuff in there (not just sorting-related, of course) that leads to really expressive code. Check it out!

Answer 3

Use the API sort(List list, Comparator c)which specifies a comparator, and implement is as you wish.

Alternatively, if you do not specifically need a List, use a SortedSet, same goes with the comparator.

Answer 4

public class Foo
   implements Comparable<Foo>
{

    private String aField;

    public Foo(String s)
       {
       aField=s;
        }


    public String getAField()
        {
        return aField;
        }

   public int compareTo(Foo other)
        {
        return getAField().compareTo(other.getAField());
        }


    @Override
    public String toString()
    {
    return getAField();
    }

}

and then

Collections.sort(list);

Answer 5

The Java 8 version:

list.sort(Comparator.comparing(Object::toString));

Or streaming:

List<Foo> sortedList = unsortedList
    .stream()
    .sorted(Comparator.comparing(Object::toString)))
    .collect(Collectors.toList());

Answer 6

I would do something very similar to Pierre:

public class Foo implements Comparable<Foo>
{
    private String aField;

    @Override
    public String toString()
    {
        return aField;
    }

    public int compareTo(Foo o)
    {
        return this.toString().compareTo(o.toString());
    }
}

Then, like Pierre, I would use Collections.sort(list) as Pierre suggests.

Answer 7

lambdaj allows you to sort, filter and in general manipulate collections without writing loops or obscure inner classes. For example the sorting you were asking can be achieved as it follows:

sort(foos, on(Foo.class).toString());

If you are interested in it check it out at:

http://code.google.com/p/lambdaj/

Answer 8

I would strongly advise you to only use toString for debugging purposes... however... to expand on what Yuval A wrote above...

public class X
    implements Comparator
{
    public int compare(final Foo a, final Foo b) 
    {
        return (a.toString().compareTo(b.toString()));
    }
}

However you really should have Foo implement Comarable or write a proper Compartor that does not make use of toString.

Answer 9

If you want the collection to remain sorted, rather than sorting it at specific points, you could put it in a TreeSet with a defined Comparator. Otherwise, I'd use the Collections.sort method already mentioned by Yuval.

Answer 10

Sort ArrayList on POJO int property (Ascending or Descending):

Collections.sort(myPojoList, (a, b) -> a.getId() - b.getId()); //ASC
Collections.sort(myPojoList, (a, b) -> b.getId() - a.getId()); //DESC

//Alternatively use Integer.compare()
Collections.sort(myPojoList, (a, b) -> Integer.compare(a.getId(), b.getId())); //ASC
Collections.sort(myPojoList, (a, b) -> Integer.compare(b.getId(), a.getId())); //DESC

Sort ArrayList on POJO String property:

Collections.sort(myPojoList, (a, b) -> a.getName().compareTo(b.getName())); //ASC
Collections.sort(myPojoList, (a, b) -> b.getName().compareTo(a.getName())); //DESC

Sort ArrayList on POJO Boolean property:

Collections.sort(myPojoList, (a, b) -> Boolean.compare(a.isMale(), b.isMale())); //ASC
Collections.sort(myPojoList, (a, b) -> Boolean.compare(b.isMale(), a.isMale())); //DESC

Extra: get distinct ArrayList

myPojoList= new ArrayList<>(new LinkedHashSet<>(myPojoList)); //Distinct