ArrayList sorting on the basis of object property [duplicate]

Answer 1

Implement Comparable interface

class Employee implements Comparable<Employee> {   

Add implement the method compareTo in Employee class like this:

 @Override
 public int compareTo(Employee other) {
     return this.age - other.age;
 }

Then you can sort your list like here:

Collections.sort(empList)

Answer 2

You need to write a Comparator.

class EmployeeAgeComparator implements Comparator<Employee>
{
    @Override
    public int compare(Employee e1, Employee e2)
    {
        if (e1.getAge() > e2.getAge())
        {
            return -1;
        } 
        else if (e1.getAge() < e2.getAge())
        {
            return 1;
        }
        return 0;
    }
}

Then use Collections.sort method like this.

Collections.sort(empList, new EmployeeAgeComparator());

Hope this helps.

Answer 3

I think you might want to sort on different properties, so in that case you should create the appropriate Comparators and use that with the proper sort method (the one which requires that too).

Answer 4

You can use the Collections.sort method with a custom Comparator:

 import java.util.Collections;
 import java.util.Comparator;

 [...]

 Collections.sort(empList, new Comparator<Employee>() {
                @Override public int compare(Employee x, Employee y) {
                   return Integer.compare(x.getAge(), y.getAge());
                }
            });

I used anonymous Comparator class, you can also write an ordinary Comparator class, see Sri Harsha Chilakapati answer.

Answer 5

This is a simple sorting algorithm. We store the subscript value of the lowest age so we can swap it.

for (int i = 0; i < empList.size(); i++)
        {
            int smallest = i;
            for (int j = i; j < numbers.length; j++)
            {
                if (empList.get(j).getAge() < emplist.get(smallest).getAge())
                    smallest = j;
            }

            int temp = empList.get(i).getAge();

            empList.set(i, empList.get(smallest))
            empList.set(smallest, temp);
        }

Answer 6

Letting the class implement the Comparable interface, as suggested in the other answers, is one option.

But in general, I'd recommend to NOT implement the Comparable interface, as long as the class does not have an undoubted natural ordering. And for Employee, there is certainly NO natural ordering.

Imagine you want to sort the Employees according to their age. Once in ascending order, and once in descending order. How could you do that? Now imagine you want to sort them once by their age, and once alphabetically, by their first name. You could not do this, without implementing a Comparator. And that's what I'd recommend here:

You can create a method like

private static Comparator<Employee> byAge()
{
    return new Comparator<Employee>()
    {
        @Override
        public int compare(Employee o1, Employee o2)
        {
            return o1.getAge() - o2.getAge();
        }
    };        
}

Then you can simply call

Collections.sort(empList, byAge());

If you want to sort them in reverse order, you can call

Collections.sort(empList, Collections.reverseOrder(byAge()));

If you want to sort them by their name, you can create a method

private static Comparator<Employee> byName()
{
    return new Comparator<Employee>()
    {
        @Override
        public int compare(Employee o1, Employee o2)
        {
            return o1.getName().compareTo(o2.getName());
        }
    };        
}

And sort them with

    Collections.sort(empList, byName());

This is much more versatile than implementing Comparable.