Help needing in using Comparator to sort BY multiple elements in ArrayList

[Melinda Savoy]

I have a a list called commonList.getCommonListItems.

In this list I have multiple elements and I'm needing to sort by 2 elements within this list: first by binSortCode and then by itemDescr

I've been googling and trying to get some help but am having problems trying to understanding comparable vs comparator. I had used comparable to sort on a single element and it worked find but when trying to sort on multiple elements I'm not able to make it work.

I have created a comparator class where I am trying to sort first on binSortCode and then sort on itemDesc, please see the following:

public class CommonListItemSort implements Comparator<CommonListItem>{

	//Sort common list items by bin sort code then by item description
	public int compare(CommonListItem o1, CommonListItem o2) {
		int diff = o1.getBinSortCode().compareToIgnoreCase(o2.getBinSortCode());
		if (diff == 0)
			diff = o1.getItemDesc().compareToIgnoreCase(o2.getItemDesc());
		return diff;
    }
}

I then call this class from my servicebean as follows:

public CommonList getDetails(final String entityCode, final String commonListName) {
		CommonList commonList = commonListDao.find(commonListName, entityCode);

		//Sort the items by binsortcode and then by item description
		Collections.sort(commonList.getCommonListItems(), new CommonListItemSort());
		return commonList;
	}

The outcome that I'm getting is that the binSortCode is in desc order and the itemdesc is in asc order.

As stated above, I need the sort to reflect: binSortCode in ASC order and then the itemDesc in ASC order.

Any help or direction would be greatly appreciated.

Regards.

[Robert Waals]

An object implementing the Comparable interface defines how to compare itself against other objects. When implementing this interface you have to implement the compareTo method. For more information click here.

A Comparator class allows you to sort on the criteria you specify yourself (or by using the compareTo method when you want to use both approaches). To sort on multiple levels you can create a nested Comparator class.

A small example:

public class CompositeComparator implements Comparator {

   private Collection<Your Specific Comparator Class> comparators;

    public CompositeComparator(Collection<Your Specific Comparator Class> comparators) {
        this.comparators= comparators;
    }
    
    public int compare(Object o1, Object o2) {
        for (Comparator comparator: comparators) {
            int result = comparator.compare(o1, o2);
            return result;
        }
        return 0;
    }
}

This can then be used in the following way:

CompositeComparator cc = new CompositeComparator(comparators);
Collections.sort(c, cc);

Regards,
Robert Jan

[Melinda Savoy]

Robert,

I guess I'm not clear by what you sent. Are you saying that I need to add this CompositeComparator class to work with what I already have?

[Campbell Ritchie]

There is a simpler alternative, which is to sort with two different Comparators one after the other. More details in the API where the important fact is that the sort is "stable."

[Melinda Savoy]

Campbell,

I tried doing what you've suggested but it did not keep the sort from the first comparator and just overwrote what sort was there with the second comparator.

I'll look at he API again. Perhaps I did something wrong.

[Ankit Garg]

Campbell Ritchie wrote:There is a simpler alternative, which is to sort with two different Comparators one after the other.

Well Campbell I don't know if I am right, but I think this will not work. If I understand it correctly, the sorting is to be done in this manner

Suppose I have a student class with fields name and age. Now I have to sort it with Age and if age is same for two or more children, then I have to sort them according to their name. Example if I have this list

Ankit, 20
Mayur, 23
Ram, 20
Aakash, 23

Then the sorting should be

Ankit, 20
Ram, 20
Aakash, 23
Mayur, 23

This can be done by using the comparator that you have already implemented. I made this code to show the functionality

import java.util.*;

class Student implements Comparable<Student>
{
	String name;
	int age;
	Student(String name, int age) {
		this.name = name;
		this.age = age;
	}
	public int compareTo(Student s2) {
		int diff = age - s2.age;
		if(diff == 0)
		{
			diff = name.compareTo(s2.name);
		}
		return diff;
	}
	public String toString()
	{
		return name+":"+age;
	}
}
class SortingTry
{
	public static void main(String[] args)
	{
		List<Student> unsorted = new ArrayList<Student>();
		unsorted.add(new Student("Ankit",20));
		unsorted.add(new Student("Kaleem",23));
		unsorted.add(new Student("Karni",22));
		unsorted.add(new Student("Ram",20));
		unsorted.add(new Student("Vijay",22));
		unsorted.add(new Student("Ranjeet",23));
		unsorted.add(new Student("Mohan",20));
		Collections.sort(unsorted);
		System.out.println(unsorted);
	}
}

[Melinda Savoy]

Ankit,

I think your example looks exactly, or almost, like the code that I'm having issues with that I posted initially.

However, the sort is not being done first by the binSortCode and THEN by the itemdesc fields. That is where my dilemma is.

The sort results I got where:

the binSortCode was in DESC order and the itemDesc was in ASC order.

I need the binSortCode to sort first then followed by the itemDesc to sort second maintaining the first sort of the binSortCode.

Hope that makes sense. Can you please look at the initial post? Thanks.

[Ankit Garg]

Can you do two things. Just post the code of the CommonListItem class and also try compareTo instead of compareToIgnoreCase...

[Jelle Klap]

Ankit Garg wrote:

Campbell Ritchie wrote:There is a simpler alternative, which is to sort with two different Comparators one after the other.

Well Campbell I don't if I am right, but I think this will not work. If I understand it correctly, the sorting is to be done in this manner

It should work if the sorting alorithm is stable (meaning equal objects aren't reorderd), like Campbell said.
For instance, let's say you have an unsorted list of objects, each of which contains two fields. This could be represented by the following sequence:

D, 3
A, 2
D, 6
A, 8
B, 5
A, 3
C, 1

Now, let's say you want this list to be first sorted alphabetically (ignoring character case for the sake of simplicitly) by the first column and then nummerically by the by the second column.
Let's say you've written two distinct Comparator implementations that do just that. First you should use the Comparator that sorts the list nummerically - which is the least significant field in the overall sorting sequence.
You'll end up with the following sequence:

C, 1
A, 2
D, 3
A, 3
B, 5
D, 6
A, 8

Obviously you're not there yet, because you still have to meet the primary sorting requirement, so let's apply that Comparator to the intermediate result:

A, 2
A, 3
A, 8
B, 5
C, 1
D, 3
D, 6

Et voilá! If you apply the Comparators sequentially in a back-to-front order (i.e. first sorting by the field that the final sequence should be ordered by last) it all works out beautifully.

[Melinda Savoy]

Ankit,

Here is the CommonListItem class and I will try to just use compare method, thanks :

public class CommonListItem implements Serializable, Comparable<CommonListItem> {

	private static final long serialVersionUID = 2445980233803032051L;
	private String				binSortCode;
	private	String				chargeToDeptCode;
	private boolean				chargeToOverride;
	private String				commonListCode;
	private String				commonListDesc;
	private Date				createDate;
	private String				entityCode;
	private String				GLAcctNum;
	private String				issueInd;
	private String				itemDesc;
	private String				itemNum;
	private String				logonId;
	private String				necCode;
	private String				parQty;
	private boolean				patientCharge;
	private String				recrdStatusCode;
	private Date				recrdStatusDate;
	private String				recrdType;
	private String				srcOverride;
	private boolean				toDelete;
	private String				typeCode;

	private List<Audit>			itemAudits;

	/**
	 * Creates an uninitialized CommonListItem instance.
	 */
	public CommonListItem() {
		super();
		itemAudits = new ArrayList<Audit>();
	}

	public boolean isEmpty() {
		return	itemNum == null
				&& binSortCode == null
				&& parQty == null
				&& chargeToDeptCode == null;
	}

	/**
	 * @return the binSortCode
	 */
	public String getBinSortCode() {
		return binSortCode;
	}

	/**
	 * @param binSortCode the binSortCode to set
	 */
	public void setBinSortCode(String binSortCode) {
		this.binSortCode = binSortCode;
	}
	
	/**
	 * @return the chargeToDeptCode
	 */
	public String getChargeToDeptCode() {
		return chargeToDeptCode;
	}
	
	/**
	 * @param chargeToDeptCode the chargeToDeptCode to set
	 */
	public void setChargeToDeptCode(String chargeToDeptCode) {
		this.chargeToDeptCode = chargeToDeptCode;
	}

	/**
	 * @return the chargeToOverride
	 */
	public boolean isChargeToOverride() {
			return chargeToOverride;
	}

	/**
	 * @param chargeToOverride the chargeToOverride to set
	 */
	public void setChargeToOverride(boolean chargeToOverride) {
		this.chargeToOverride = chargeToOverride;
	}

	/**
	 * @return the commonListCode
	 */
	public String getCommonListCode() {
		return commonListCode;
	}

	/**
	 * @param commonListCode the commonListCode to set
	 */
	public void setCommonListCode(String commonListCode) {
		this.commonListCode = commonListCode;
	}

	/**
	 * @return the commonListDesc
	 */
	public String getCommonListDesc() {
		return commonListDesc;
	}

	/**
	 * @param commonListDesc the commonListDesc to set
	 */
	public void setCommonListDesc(String commonListDesc) {
		this.commonListDesc = commonListDesc;
	}

	/**
	 * @return the createDate
	 */
	public Date getCreateDate() {
		return createDate;
	}

	/**
	 * @param createDate the createDate to set
	 */
	public void setCreateDate(Date createDate) {
		this.createDate = createDate;
	}

	/**
	 * @return the entityCode
	 */
	public String getEntityCode() {
		return entityCode;
	}

	/**
	 * @param entityCode the entityCode to set
	 */
	public void setEntityCode(String entityCode) {
		this.entityCode = entityCode;
	}

	/**
	 * @return the gLAcctNum
	 */
	public String getGLAcctNum() {
		return GLAcctNum;
	}

	/**
	 * @param acctNum the gLAcctNum to set
	 */
	public void setGLAcctNum(String GLAcctNum) {
		this.GLAcctNum = GLAcctNum;
	}

	/**
	 * @return the issueInd
	 */
	public String getIssueInd() {
		return issueInd;
	}

	/**
	 * @param issueInd the issueInd to set
	 */
	public void setIssueInd(String issueInd) {
		this.issueInd = issueInd;
	}

	/**
	 * @return the itemDesc
	 */
	public String getItemDesc() {
		return itemDesc;
	}

	/**
	 * @param itemDesc the itemDesc to set
	 */
	public void setItemDesc(String itemDesc) {
		this.itemDesc = itemDesc;
	}

	/**
	 * @return the itemNum
	 */
	public String getItemNum() {
		return itemNum;
	}

	/**
	 * @param itemNum the itemNum to set
	 */
	public void setItemNum(String itemNum) {
		this.itemNum = itemNum;
	}

	/**
	 * @return the logonId
	 */
	public String getLogonId() {
		return logonId;
	}

	/**
	 * @param logonId the logonId to set
	 */
	public void setLogonId(String logonId) {
		this.logonId = logonId;
	}

	/**
	 * @return the necCode
	 */
	public String getNecCode() {
		return necCode;
	}

	/**
	 * @param necCode the necCode to set
	 */
	public void setNecCode(String necCode) {
		this.necCode = necCode;
	}

	/**
	 * @return the parQty
	 */
	public String getParQty() {
		return parQty;
	}

	/**
	 * @param parQty the parQty to set
	 */
	public void setParQty(String parQty) {
		this.parQty = parQty;
	}

	/**
	 * @return the patientCharge
	 */
	public boolean isPatientCharge() {
		return patientCharge;
	}

	/**
	 * @param patientCharge the patientCharge to set
	 */
	public void setPatientCharge(boolean patientCharge) {
		this.patientCharge = patientCharge;
	}

	/**
	 * @return the recrdStatusCode
	 */
	public String getRecrdStatusCode() {
		return recrdStatusCode;
	}

	/**
	 * @param recrdStatusCode the recrdStatusCode to set
	 */
	public void setRecrdStatusCode(String recrdStatusCode) {
		this.recrdStatusCode = recrdStatusCode;
	}

	/**
	 * @return the recrdStatusDate
	 */
	public Date getRecrdStatusDate() {
		return recrdStatusDate;
	}

	/**
	 * @param recrdStatusDate the recrdStatusDate to set
	 */
	public void setRecrdStatusDate(Date recrdStatusDate) {
		this.recrdStatusDate = recrdStatusDate;
	}

	/**
	 * @return the recrdType
	 */
	public String getRecrdType() {
		return recrdType;
	}

	/**
	 * @param recrdType the recrdType to set
	 */
	public void setRecrdType(String recrdType) {
		this.recrdType = recrdType;
	}

	/**
	 * @return the srcOverride
	 */
	public String getSrcOverride() {
		return srcOverride;
	}

	/**
	 * @param srcOverride the srcOverride to set
	 */
	public void setSrcOverride(String srcOverride) {
		this.srcOverride = srcOverride;
	}
	
	/**
	 * Returns the toDelete value.
	 * 
	 * @return the toDelete value.
	 */
	public boolean isDelete() {
		return toDelete;
	}
	
	/**
	 * Sets the toDelete value.
	 * 
	 * @param toDelete the toDelete value to set.
	 */
	public void setDelete(boolean toDelete) {
		this.toDelete = toDelete;
	}

	/**
	 * @return the typeCode
	 */
	public String getTypeCode() {
		return typeCode;
	}

	/**
	 * @param typeCode the typeCode to set
	 */
	public void setTypeCode(String typeCode) {
		this.typeCode = typeCode;
	}

	/**
	 * @return the itemAudits
	 */
	public List<Audit> getItemAudits() {
		return itemAudits;
	}

	/**
	 * @param itemAudits the itemAudits to set
	 */
	public void addItemAudit(Audit itemAudit) {
		itemAudits.add(itemAudit);
	}
	
	/**
	 * Returns the isItemAudit value.
	 * 
	 * @return the isItemAudit value.
	 */
	public boolean isItemAudit() {
		return itemAudits.size() > 0;
	}
	
	@Override
	public boolean equals(final Object o) {
		return (Java.equals(itemNum, ((CommonListItem) o).itemNum));
	}

[Ankit Garg]

Jelle you are right. I have never every thought or heard about that solution. I was hesitating to write that Campbell was wrong as I know that he is among the most respected people out here. That's why I wrote

I don't know if I am right, but I think this will not work

I knew that I would be wrong at the end

I still have a lot to learn before I can dare to directly say that Campbell you are wrong

[Ankit Garg]

Melinda I don't see anything wrong with that code. Why don't you try what Campbell and Jelle said i.e. implement two comparators...

[Melinda Savoy]

Thanks for all the help. I will try my initial code again.

Regards.

[Campbell Ritchie]

Why don't you tell me when you think I am wrong? Joanne Neal does all the time!

Actually, you are right. You have to implement one Comparator, then if that returns 0 try the other Comparator. Since the sorting is "stable", if both Comparators return 0, then the two elements are left in their initial locations.

Anyway some good came of it; my mistake made for a much more interesting discussion.

[Campbell Ritchie]

By the way, that equals() method looks suspect to me. The equals() method takes Object as a parameter, so you can pass any reference type to it, but anything other than the correct type will generate a ClassCastException. You need to test for type (details in books like Effectvie Java by Joshua Bloch, or on that most useful website of Angelika Langer's), and you also need to override the Object#hashCode() method.