Sorting

[Ananth Ram]

Hi All,

Please find the code below.

public class ObjPlcy implements Serializable
{
private int plcyID = 0;
private Vector ObjPlcyLb = new Vector();
}

public class ObjPlyLB implements Serializable
{
private int plcyLBID = 0;
private int plcyID = 0;
private int Priority = 0;
}

Now, I have created a Vector vBuffPlcy comprising of objPlcy which again have objPlcyLB that has a prority code in it. I want to sort based on the priority code and set the Vector of ObjPlcy based on the same. I have written the logic below, and it is not working in all scenarios.

Could someone throw light on the same.


while(vBuffPolicy.size() > 0)
{
int iPos = 0;
// use the first element for comparison
ObjPlcy oPol1 = (ObjPlcy)vBuffPolicy.firstElement();

for(int iLOB1 = 0; iLOB1 < oPol1.getObjPlcyLb().size(); iLOB1++)
oLOB1 = (ObjPlcyLB)oPol1.getObjPlcyLb().get(iLOB1);

for (int j = 0; j < vBuffPolicy.size(); j++)
{

//second element for comparison
ObjPlcy oPol2 = (ObjPlcy)vBuffPolicy.get(j);

for(int iLOB2 = 0; iLOB2 < oPol2.getObjPlcyLb().size(); iLOB2++)
oLOB2 = (ObjPlcyLB)oPol2.getObjPlcyLb().get(iLOB2);


if (oLOB2.getPriority() < oLOB1.getPriority())
{
iPos = j;
oPol1 = oPol2;
}
}

//lets add this item to the sorted Vector
vBuffPolicy.removeElementAt(iPos);
vSortPlcy.addElement(oPol1);
}

Thanks in advance for the help.

[Ernest Friedman-Hill]

Forget this -- instead look at the static java.util.Collections.sort() methods, and the java.util.Comparator interface. It's silly to write your own sorting method -- the easy ones are slow, and the fast ones are hard to get right.

[Ananth Ram]

Thanks,

Let me try using Collection.sort().......

[arulk pillai]

The classes, which implement the Comparable interface, impose natural order. By implementing Comparable, sorting an array of objects or a collection (List etc) is as simple as:

Arrays.sort(myArray);
Collections.sort(myCollection); // do not confuse �Collections� utility 
                                // class with the  "Collection� interface 
                                //without an �s�.

 ...imports
 
public class Pet implements Comparable {
    
  int petId;
  String petType;
    
  public Pet(int argPetId, String argPetType) {
      petId = argPetId;
      this.petType = argPetType;
  }
    
  public int compareTo(Object o) {
       Pet petAnother = (Pet)o;
        
       //natural alphabetical ordering by type
       //if equal returns 0, if greater returns +ve int,
       //if less returns -ve int
       return this.petType.compareTo(petAnother.petType);
  }
    
    
  public static void main(String[] args) {
     List list = new ArrayList();
     list.add(new Pet(2, "Dog"));
     list.add(new Pet(1, "Parrot"));
     list.add(new Pet(2, "Cat"));
        
     Collections.sort(list); // sorts using compareTo method
       
    for (Iterator iter = list.iterator(); iter.hasNext() :wink:  {
        Pet element = (Pet) iter.next();
        System.out.println(element);
    } 
  }
    
  public String toString() {
      return petType;
  }
 
}
Output:  Cat, Dog, Parrot
   

For classes that don�t implement Comparable interface, or when one needs even more control over ordering based on multiple attributes, a Comparator interface should be used.

 ...imports
 
public class PetComparator implements Comparator, Serializable{
 
   public int compare(Object o1, Object o2) { 
      int result = 0;
        
      Pet pet = (Pet)o1;
      Pet petAnother = (Pet)o2;
     
      //use Integer class's natural ordering 
      Integer pId = new Integer(pet.getPetId());
      Integer pAnotherId = new Integer(petAnother.getPetId());
        
      result = pId.compareTo(pAnotherId);
        
      //if ids are same compare by petType
      if(result == 0) {
          result= pet.getPetType().compareTo
                   (petAnother.getPetType());
      }
        
       return result;
    }
    
    
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Pet(2, "Dog"));
        list.add(new Pet(1, "Parrot"));
        list.add(new Pet(2, "Cat"));
        
       Collections.sort(list, new PetComparator());
        
       for (Iterator iter = list.iterator(); iter.hasNext() :wink: {
           Pet element = (Pet) iter.next();
           System.out.println(element);
       }  
    }
}
 
Output:  Parrot, Cat, Dog.
 

Note: some methods are not shown for brevity.
   

For advanced users, The Apache's BeanComparator can simplify things further.

[Henry Wong]

It's silly to write your own sorting method -- the easy ones are slow, and the fast ones are hard to get right.

Unless, of course, this is a homework assignment, and it is required to write your own sorting method.

Henry

[Sam Aran]

Also, don't use Vector, because Vector is ArrayList's retarded older brother. Use an ArrayList instead, always (even if you need some synchronization, it is not worth the hit of all of the Vector methods being synchronized).

[Campbell Ritchie]

Originally posted by Samus Aran:
. . . retarded older brother . . .

What a turn of phrase!

[Rob Spoor]

"Samus Aran",

Please check your private messages regarding an important announcement.

Thank you,

Rob