Please help with sorting multiple columns

[jay lai]

I have the similar problem with this post
sort

I have a method to do the sort, the whole list is in ArrayList, and I need to sort first column first , and then if the second columns:

For example: sorted by name and within name of 1st column sorted by State
Name | State
--------------
Adam | Arizona
Adam | Vermon
Zoo | Maryland
Zoo | New England
Zoo | Virginia

I got things works only sorted on the first columns ONLY?
Can any one help me how to sorted the seconde one and the first one still be sorted too...?j

Many thanks in advance

public class MySort implements Comparator
{
  private String methodName;
  public MySort (String methodName) 
  {
  this.methodName = methodName;
  }
  
  public int compare(Object o1, Object o2) 
  {
  try
  {
   Method m1 = o1.getClass().getMethod(methodName, new Class[] {});
   Method m2 = o1.getClass().getMethod(methodName, new Class[] {});
   return ((String) m1.invoke(o1, new Object[] {})).compareTo ((String)    m2.invoke(o2, new Object[] {}));
  }
  catch (Exception e)
  {
  throw new RuntimeException("exception" , e);
  }
  }
 
  public static void sortList(ArrayList result, String sortField, boolean asc)
 {
  if ("name".equals(sortField))
  {
  Collections.sort(result, new MySort("getName")); // another BeanObject contain these values setter/getter for "name" , "state"
  }
  else if ("state".equals(sortField))
  {
  Collections.sort(result, new MySort("getState"));
  }
 }
}
[CODE]  To invoke the MySort class
[B] ArrayList listResult = new ArrayList();
 listResult.add( new MyBean(.....));
 MySort (listResult, "name", true);[/B]

[Joel McNary]

The Collections.sort method is "is guaranteed to be stable: equal elements will not be reordered as a result of the sort." (From the javadoc).

What does this mean? To do what you want to do, first sort by the least significant column and then work your way to the most significant. In this case, sort by State first and then Name.

For example, the input:

Zoo | New England
Adam | Arizona
Zoo | Maryland
Adam | Vermont
Zoo | Virginia

When sorted by State:

Adam | Arizona
Zoo | Maryland
Zoo | New England
Adam | Vermont
Zoo | Virginia

And then by Name:

Adam | Arizona
Adam | Vermont
Zoo | Maryland
Zoo | New England
Zoo | Virginia

The relative positions of Maryland, New England, and Virginia are not changed because this is a stable sort.

[jay lai]

Thanks Joel McNary ,
Can you giving more detail, in term of coding, for example: I just keep the way I do in MySort class, and just calling it twice, First path: passing the getState, then second path : passing getName?

MySort(listresult, "state", true)
MySort(listresult, "name", true)?

thank you in advance

[jay lai]

Can anyone please help, this is urgent...
Greatly appreciated.

[Burkhard Hassel]

Hi,

you'll need two comparators, one for the name and one for the state.

See java.util.Comparator in the API.

Then:
Collections.sort(list, new StateComparator());
Collections.sort(list, new NameComparator());


Yours,
Bu.

[Stan James]

Can you modify MySort? What if it had a constructor like

new MySort( "getState", "getName" );

Comparators often do something like

int result = a.field1.compareTo( b.field1 );
if (result == 0)
   result = a.field2.compareTo( b.field2 );

Your generic MySort could loop through any number of methods or fields until it gets a non-zero result. Java5 supports "varargs" syntax, so you wouldn't even break existing code by accepting an array of method names.

[jay lai]

Stan: so are you saying that i would do something like this, So what do I do with the Compare method? Thank you in advance

public class MySort implements Comparator{  
private String methodName;  
private String methodName2;
public MySort (String methodName)   
{  
this.methodName = methodName;  
}    
 
[B]public MySort (String methodName, String methodName2)
{
this.methodName = methodName;
this.methodName2 = methodName2;
}[/B]
[B]public int compare(Object o1, Object o2)   {  
try  { 
Method m1 = o1.getClass().getMethod(methodName, new Class[] {});   
Method m2 = o1.getClass().getMethod(methodName, new Class[] {});   
return ((String) m1.invoke(o1, new Object[] {})).compareTo ((String)    m2.invoke(o2, new Object[] {}));  
} [/B] // WHAT DO I DO WITH THIS COMPARE?
catch (Exception e)  {  
throw new RuntimeException("exception" , e);  
}  
}   
public static void sortList(ArrayList result, String sortField, boolean asc) {  
if ("name".equals(sortField) || "state".equals(sortField))  {  
[B]Collections.sort(result, new MySort("getName", "getState"));[/B]}
}

[steve souza]

I did something similar with my open source project www.fdsapi.com. I allow you to write sql against Object[][] and I needed this capability to support the order by clause. With slight modifications this should work for you, or you could simply make an Object[][] at of your data and you wouldn't have to write this code. fyi Your code only sorts by one column at a time.

Example:
select * from array order by col1 desc, col4 asc, col8 asc

Here is the class that does this. Primarily focus on the compare method. I have a list of Comparators I loop through. To see sample usage code look in the main method.

http://fdsapi.cvs.sourceforge.net/fdsapi/fdsapi/Code/com/fdsapi/arrays/ArrayComparator.java?revision=1.12&view=markup
[ July 01, 2007: Message edited by: steve souza ]

[jay lai]

Thanks Steve
I am going to look into it,
Greatly appreciated for your sharing and helping.
Regards

[jay lai]

Hi Steve:
After look into the ArrayComparator , I would create a ArrayComparator.java in Utils, and from my caller class:

  Utils.ArrayComparator ac = new ArrayComparator();
  ArrayList resultList = new ArrayList();
  Object [][] array = resultList.toArray();
  resultList.add (new ValueObject("name", "state");
  ac.addSortCol(0,"asc");
  ac.addSortCol(1,"desc");
  ac.sort(array);
  

Please let me know if I am on the right track by using your class.
Tons of thanks in advance

 public class ArrayComparator extends java.lang.Object implements Comparator
{
 public ArrayComparator(int sortCol, String direction) {
        addSortCol(sortCol, direction);
    }
  public void addSortCol(int sortCol, String direction) {
   addToString("col"+sortCol, direction);
   sortCols.add(new ElementComparator(sortCol, direction));
 }
 
 private void addToString(String sortColName, String direction) {
   String comma=isFirstOrderBy ? "order by " : ", ";
   sortStr+=comma+sortColName+" "+direction;   
   isFirstOrderBy=false;
 }
 
 
public int compare(Object o1, Object o2) {
      int compareVal=0;
      Iterator iter=sortCols.iterator();
      while (iter.hasNext()) {
           ElementComparator elementComp=(ElementComparator) iter.next();
           Object element1=((Object[]) o1)[elementComp.getSortCol()];
           Object element2=((Object[]) o2)[elementComp.getSortCol()];
 
           compareVal=elementComp.compare(element1,element2);
           if (compareVal!=0) // if one of the elments is not equal we know all we need to know and can return
             break;
       }
 
      return compareVal;
}
 
 // java.util.Arrays.equals(data,copy(data));  The row pointers and data in them are the same.
 public static Object[][] copy(Object[][] data) {
       if (data==null)
         return null;
       else {
         Object[][] copyData=new Object[data.length][];
         System.arraycopy(data,0, copyData,0,data.length);
         return copyData;
       }
    }
    
 
/*** Start ElementComparator inner class ***/
 // Used to compare elements of an array that reside within the same column.  The Object[][] array itself
 // will be sorted according to this algorithm.
 private static class ElementComparator implements Comparator {
    private int sortCol;
    private static final int ASC=0;
    private static final int DESC=1;
    private int dir;
 
    public ElementComparator(int sortCol, String direction) {
        this.sortCol=sortCol;
        if ("asc".equalsIgnoreCase(direction) || "ascending".equalsIgnoreCase(direction))
         dir=ASC;
        else if ("desc".equalsIgnoreCase(direction) || "descending".equalsIgnoreCase(direction))
         dir=DESC;
        else
         throw new IllegalArgumentException("'asc' or 'desc' must be passed to the constructor.  The argument passed was: "+direction);
    }
 
    private boolean isAscending()  {
      return dir==ASC;   
    }
 public int compare(Object o1, Object o2) {
     Comparable comparable=null;
     Object element1=o1;
     Object element2=o2;
 
     // Note the following if condition ensures that nulls may be in the array.  Nulls will always
     // be placed after all other data with the following logic.
     if (element1==null && element2==null) 
       return 0;
     else if (element1==null) 
       return 1;
     else if (element2==null)
       return -1;
     else 
       comparable = (Comparable) element1;
 

     if (isAscending())
        return comparable.compareTo(element2);
     else
        return -comparable.compareTo(element2);
  }
 
 }
  public static void main(String[] args) throws Exception {
  ArrayComparator ac=new ArrayComparator();
    ac.addSortCol(0,"asc");
    ac.addSortCol(1,"desc");
    ac.addSortCol(2,"asc");
    ac.sort(array);  //
}
 
}
 

[steve souza]

You just seem like you have copied my code. If you are just trying to sort arrays then my code already does that and you could use it. If you are trying to sort by reflection (which is what it looks like due to your call to ValueObject) then you will have to change my code. What does this ValueObject do? Is this a homework assignment? I gave you working code, and it doesn't look like you have gone to much effort to understand it.

[jay lai]

The ValueObject is just a class store all the field the represent the columns needed to be sort on.

I read your code througoutly and try to make modified according to my need, some of your class library are not there, therefore i need to remove it.


class ValueObject
{
String name;
String state;
public ValueObject (String name, String state)
{

}
}

[jay lai]

The ValueObject is just a class store all the field the represent the columns needed to be sort on.

I read your code througoutly and try to make modified according to my need, some of your class library are not there, therefore i need to remove it.

My purpose is to create an ArrayList and add all the value into this ValueObject then sort the object using some of your "existing" code algorimth..

ArrayList myArray = new ArrayList();
myArray.add (new ValueObject(someValueforname, someValueforState);
 

Also this is not a homework, this is for work.
Thanks again.

class ValueObject
{
 String name;
 String state;
 public ValueObject (String name, String state)
 {
  this.name = name;
  this.state = state;
 }
 public String getName()
 {
 return name;
 }
 public void setName(String name)
 {
 this.name = name;
 }
 
 public String getState()
 {
 return state;
 }
 
 public void setState(String state)
 {
 this.state = state;
 }
}