Sort array - by two fields

[Sharon whipple]

Hi
I have List of Users : List<User>
Each User have First-Name and Last-Name,
How do I sort the list by First-Name and then Last-Name?

Thank you

[Manuel Leiria]

Your User class must implement the interface Comparable. Check this example:

Interface Comparable

[bart zagers]

The easiest way to sort an array is using the Collections.sort methods. You have a choice of two methods.
If your object has a natural order, you can consider to make it implement the Comparable interface (as Manuel suggested). In this case the list can be sorted according to this order.
Another option is to implement a Comparator an sort the list according to this, using the second sort method.

For example in this case to me the natural order for Users would be to sort by last name and then first name, so I would probably implement a Comparator to sort by first name and last name, however you might feel different (or your use case might be different).

[Sharon whipple]

Thank you
It's working great!

I ran into a little bit more complicated case,
Say I want to Sort users by their attributes for example UserClass has three fields UserStatus (Enum), UserDegree(Enum), Department(Enum)

I would like to sort the userList by several given lists
For example:
List<User> userList

MySorter.addSorter(Department,list<Department>(R&D,Accounting,Testing))
MySorter.addSorter(UserStatus ,list<UserStatus>(OutSourcing, fixed, unemployed))
MySorter.addSorter(UserDegree,list<UserDegree>(15,44,55))

List<User> newUserList = MySorter.sort(userList)


So newUserList will come out sorted first by Department then by UserStatus and last by UserDegree (according to the types in the list.)

In each one of the first level sort the users will come out sorted first by R&D and in R&D all OutSourcing


I will be glad to have some help.

Sharon

[Garrett Rowe]

You could do something like this :
(Note: this suggestion is untested)

import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
 
public class ComposableComparator<T> implements Comparator<T>
{
   private List<Comparator<? super T>> comps;
 
   public ComposableComparator()
   {
       comps = new LinkedList<Comparator<? super T>>();
   }
 
   public int compare(T a, T b)
   {
      for (Comparator<? super T> c : comps)
      {
          int result = c.compare(a, b);
          if (result != 0)
          {
              return result;
          }
      }
      return 0;
   }
 
   public void add(Comparator<? super T> comp)
   {
      comps.add(comp);
   }
}

[ May 21, 2008: Message edited by: Garrett Rowe ]

[Rob Spoor]

That would work. I can know - it looks quite a lot like a class I once wrote, except mine had more methods for adding, removing and querying the comparators. The compare method was identical though.

Well, with one exception: I made sure no null comparators were allowed. In this code, I'd check for null first:

int result = (c == null ? 0 : c.compare(a, b));

[Sharon whipple]

Hi Garrett
Thank you for the code,I am not sure how to use the ComposableComparator,
I made little sample to run sort on 1000 random users,

can you tell me how to set up the ComposableComparator code in SortRunner class?

Thanks again
Sharon

Class SortRunner

package com.test;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
 
import com.test.User.Department;
import com.test.User.UserDegree;
import com.test.User.UserStatus;
public class SortRunner {
 
private static final int MAX_USERS = 1000;
 
public static void main(){
SortRunner runner = new SortRunner();
runner.testSort();
}
 
private void testSort() {
 
Random rand = new Random(System.currentTimeMillis());
List<User> usersList = new ArrayList<User>(10);
 
Department[] allDept =  Department.values();
UserDegree[] allDegree = UserDegree.values();
UserStatus[] allStatus = UserStatus.values();
 
// add X Users(int id, String name, String l-name, Department department, UserDegree degree,UserStatus status) {
for(int i=0;i<MAX_USERS; i++){
usersList.add(new User(i,"userName " +i,"lastName "+i,allDept[rand.nextInt(allDegree.length)],allDegree[rand.nextInt(allDegree.length)],allStatus[rand.nextInt(allStatus.length)]));
}
 
List<Department> deptList = new ArrayList<Department>();
List<UserStatus> statusList = new ArrayList<UserStatus>();
List<UserDegree> userDegree = new ArrayList<UserDegree>();
 
deptList.add(Department.Labour);
deptList.add(Department.Administration);
deptList.add(Department.Government_Communications);
 
statusList.add(UserStatus.Offshoring);
statusList.add(UserStatus.Outsourcing);
 
userDegree.add(UserDegree.High);
userDegree.add(UserDegree.Lowest);
 

//ComposableComparator<T> code
}
}

Class User :

package com.test;
 
public class User {
 
public enum UserStatus{
Outsourcing,
Communications,
Consulting,
Consultancy,
Offshoring,
Intellectual_Property,
Contract_Services,
Broker;
}
 
public enumUserDegree{
Lowest,
Low,
Medium,
Normal,
High,
Highest,
}
 
public enum Department{
Communications,
Defence,
Government_Communications,
Health,
Agriculture,
SA_Management_Development_Institute,
Secretariat_for_Safety_Security,
Home_Affairs,
Science_Technology,
Housing_Website,
Labour,
Minerals_Energy,
Public_Enterprises,
National_Intelligence,
Land_Affairs,
SA_Revenue_Service,
National_Treasury,
Provincial_Local_Government,
Administration,
Correctional,
Public_Service,
Public_Works,
Arts_Culture,
SA_Police_Service;
}
 
private int id;
private String name;
private String lName;
private Department department;
private UserDegree degree;
private UserStatus status;
/**
 * @return the id
 */
public int getId() {
return id;
}
/**
 * @param id the id to set
 */
public void setId(int id) {
this.id = id;
}
/**
 * @return the name
 */
public String getName() {
return name;
}
/**
 * @param name the name to set
 */
public void setName(String name) {
this.name = name;
}
/**
 * @return the lName
 */
public String getLName() {
return lName;
}
/**
 * @param name the lName to set
 */
public void setLName(String name) {
lName = name;
}
/**
 * @return the department
 */
public Department getDepartment() {
return department;
}
/**
 * @param department the department to set
 */
public void setDepartment(Department department) {
this.department = department;
}
/**
 * @return the degree
 */
public UserDegree getDegree() {
return degree;
}
/**
 * @param degree the degree to set
 */
public void setDegree(UserDegree degree) {
this.degree = degree;
}
/**
 * @return the status
 */
public UserStatus getStatus() {
return status;
}
/**
 * @param status the status to set
 */
public void setStatus(UserStatus status) {
this.status = status;
}
/**
 * @param id
 * @param name
 * @param name2
 * @param department
 * @param degree
 * @param status
 */
 User(int id, String name, String lname, Department department, UserDegree degree,UserStatus status) {
super();
this.id = id;
this.name = name;
this.lName = lname;
this.department = department;
this.degree = degree;
this.status = status;
}
}

[bart zagers]

For each of the attributes you would like to sort on (e.g. departement, degree and status), you have to write a Comparator<User> that compares the users based on this single attribute. So you end up with three Comparators.
Then you create the ComposableComparator<User> and add one or more of these Comparators you have just created. Now the ComposableComparator will order the users based on the Comparators you have added, in the order you added them.
If you want the users sorted in a different order, create another ComposableComparator and add the Comparators in a different order.

deptList.add(Department.Labour);
deptList.add(Department.Administration);
deptList.add(Department.Government_Communications);

I'm sure what you want to do with this. If this means the order of the departements, this will come in the Comparator, but you will have to define an order for all possible departement values.
If you want to filter on these values, this is not done using Comparators, which is only about sorting. Filtering would be another subject.

[Sharon whipple]

I am missing something with the Generics,
should it be :

public class DepartmentComparator implements Comparable<User> {
List<Department> deptList = new ArrayList<Department>();
public int compareTo(User o) {
int i=-1;
 
for(Department dept: deptList){
i++;
if(dept.equals(o.getDepartment())){
break;
}
}
 
return  i;
}
 
private DepartmentComparator(List<Department> deptList) {
//this.deptList = deptList;
deptList.add(Department.Labour);
deptList.add(Department.Administration);
deptList.add(Department.Government_Communications);
}
}

and then :

ComposableComparator<User>  composableComparator = new ComposableComparator<User>();
DepartmentComparator departmentComparator = new DepartmentComparator();
composableComparator.add(departmentComparator);
Collections.sort(usersList,composableComparator);

[bart zagers]

You are struggling with the Comparator. Don't confuse Comparator and Comparable.
It should be something like (mind you, simplified and no compiler around).

    public class DepartmentComparator implements Comparator<User> {
        public int compare(User user1, User user2) {
        return user1.getDepartement().compareTo(user2.getDepartement());
            // Now you order based on the order of the enum
        }
    }

The usage of the ComposableComparator seems ok.

[Fixed bad typo that Garrett mentioned ]
[ May 22, 2008: Message edited by: bart zagers ]

[Garrett Rowe]

Obviously Bart means:

    public class DepartmentComparator implements Comparator<User> {
        public int compare(User user1, User user2) {
        return user1.getDepartement().compareTo(user2.getDepartement());
            // Now you order based on the order of the enum
        }
    }

[Sharon whipple]

Thank you!!!
Its working nicely, little bit polishing and enhancing and its perfect!!!


DepartmentComparator looks like :

package com.test;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
 
import com.test.User.Department;
 
public class DepartmentComparator implements Comparator<User> {
 
List<Department> deptList = new ArrayList<Department>();
 
public int compare(User user1, User user2) {
 
if(user1.getDepartment().equals(user2.getDepartment())){
return 0;
}
 
int listLength = deptList.size();
//Deliberately started with the number of elements so at the end we can see if element is found
int deptIdx1 = listLength, deptIdx2 = listLength;
 
for (int index = 0; index < listLength&& !(deptIdx1 != listLength && deptIdx2 != listLength); index++) {
if (deptList.get(index).equals(user1.getDepartment())) {
deptIdx1 = index;
} else if (deptList.get(index).equals(user2.getDepartment())) {
deptIdx2 = index;
}
}
 
return deptIdx1 - deptIdx2;
}
 
DepartmentComparator() {
deptList.add(Department.Labour);
deptList.add(Department.Administration);
deptList.add(Department.Government_Communications);
deptList.add(Department.Agriculture);
deptList.add(Department.Arts_Culture);
deptList.add(Department.Minerals_Energy);
}
}

[Garrett Rowe]

Good work. I'm not sure if you know this, but enum types implement Comparable automagically, with their natural ordering being the order in which they are declared. So if the ordering for your Department enum doesn't change, then your Comparator which sorts by Department could look like this:

public class DepartmentComparator implements Comparator<User>
{
   public int compare(User a, User b)
   {
      return a.getDepartment().compareTo(b.getDepartment());
   }
}

[ May 22, 2008: Message edited by: Garrett Rowe ]