Second order sorting using Comparable Interface

[sudha swami]

Hi,
I have the following requirement. I need to do the sorting functionality. This the sql

select * from Person
order by name asc, time desc

This is the code

  
public class BinForm  implements Comparable
{
    public String name;
    public Date receivedDate;
    public static int sortBy;
    
    // get set methods
    
    public void setName(String name)
    {
    	this.name=name;
    }
    
   
    public String getName()
    {
       return this.name;
    }
   
   
   public Date getReceivedDate() 
   {
   	return receivedDate;
   }
   	
   	
   public void setReceivedDate(Date receivedDate) 
   {
   	this.receivedDate = receivedDate;
   }


public int compareTo(Object bimForm) throws ClassCastException 
{
	    if (!(bimForm instanceof BinaryImgTransferForm))
	      throw new ClassCastException("A BinaryImgTransferForm  object expected.");
	    BinForm bimSortObj=(BinForm) bimForm;
	    switch(sortBy)
		{
			case 1:
				return this.name.compareTo(bimSortObj.name);
			case 2:	
				return this.receivedDate.compareTo(bimSortObj.receivedDate);

			default:
				return this.receivedDate.compareTo(bimSortObj.receivedDate);
			
		}		
}


// In the servlet,
BinForm.sortBy=1
Collections.sort(bimList);

  

i dont know how to do second order sorting (time desc) using comparable interface.

THanks
Sudha

[Max Rahder]

Perhaps something like this. Sorts first by height, and then by name.

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Human {
	private final String name;
	private final int height;

	public String getName() {
		return name;
	}

	public Human(String name, int height) {
		super();
		this.name = name;
		this.height = height;
	}
	
	public String toString(){
		return getName() + " is " + getHeight() + " cm tall.";
	}

	public static final Comparator<Human> HEIGHT_NAME = new Comparator<Human>() {

		public int compare(Human h1, Human h2) {
			int i = h1.getHeight() - h2.getHeight();
			if (i == 0) {
				i = h1.getName().compareToIgnoreCase(h2.getName());
			}
			return i;
		}
	};

	public int getHeight() {
		return height;
	}

	public static void main(String[] args) {
		List<Human> l = new ArrayList<Human>();
		l.add(new Human("Arnold" , 100));
		l.add(new Human("Mark"   , 100));
		l.add(new Human("Walter",  100));
		l.add(new Human("Anne"   , 120));
		l.add(new Human("Mary"   ,  90));
		l.add(new Human("Wilma"  , 100));
		System.out.println("Before sort: " + l);
		Collections.sort(l, Human.HEIGHT_NAME);
		System.out.println("After sort: " + l);
	}
}

Output:

 
Before sort: [Arnold is 100 cm tall., Mark is 100 cm tall., Walter is 100 cm tall., Anne is 120 cm tall., Mary is 90 cm tall., Wilma is 100 cm tall.]
After sort:  [Mary is 90 cm tall., Arnold is 100 cm tall., Mark is 100 cm tall., Walter is 100 cm tall., Wilma is 100 cm tall., Anne is 120 cm tall.]

[Rob Spoor]

Max Rahder wrote:

int i = h1.getHeight() - h2.getHeight();

Just a word of caution: using simple subtraction for ints can get very nasty if the ints get quite big. Consider the case where h1.getHeight() is Integer.MIN_VALUE, and h2.getHeight() is positive. The result will overflow, and produce nasty results.

If the chances of this exist, the following is much safer (and also applies to long):

int i = (h1.getHeight() < h2.getHeight() ? -1 : h1.getHeight() > h2.getHeight() ? 1 : 0);

But if you know (and can guarantee) that the int values won't get that big, subtracting is not a problem.

[sudha swami]

Hi,

Thanks for the information. The above example has height in ascending order and the name is also in the ascending order.
My requirement is : Height should be in the ascending order and name should be in descending order.
Thanks
Sudha

[Max Rahder]

sudha swami wrote:Hi, Thanks for the information. The above example has height in ascending order and the name is also in the ascending order.
My requirement is : Height should be in the ascending order and name should be in descending order.
ThanksSudha

I just gave you an example. You'll have to figure out how to apply it to your situation. Experiment a little.

[sudha swami]

I tried it the same way as you did since last few days but i couldnt figure out whethere there is an option to do one column as ascending and the other one as descending

[Rob Spoor]

For descending, all you need to do is flip the sign (e.g. -13 becomes 13, or 481 becomes -481). You can just return -(previous return value) except when the previous return value is Integer.MIN_VALUE.

[sudha swami]

Rob,
I implemented the code changes according to your suggestion(return -(previous return value) ) and it is working fine.
Thanks for your suggestion. But i dont understand

"You can just return -(previous return value) except when the previous return value is Integer.MIN_VALUE "

Thanks
Sudha

[Rob Spoor]

Integer.MIN_VALUE is -2,147,483,648, so -Integer.MIN_VALUE would be 2,147,483,648 - that is Integer.MAX_VALUE + 1. Since this is larger than Integer.MAX_VALUE, it wraps and... becomes Integer.MIN_VALUE again!

Byte.MIN_VALUE, Short.MIN_VALUE and Long.MIN_VALUE have the same issue.