java sort list of objects by specifiable attribute

Question

I want to sort a List of objects by a specified attribute of those objects and I want to choose which attribute should be used for sorting. Example:

class          


        

Answer 1

You're reinventing the wheel! Life will be much easier for you if you use the templated Collections API. To do this, you would work with List instead of arrays, define a Comparator to do your sorting, and then let the API do the work for you.

 Comparator<Car> carComparator = new Comparator<Car>(){
    public int sort(Car car1, Car car2){
      //Sorting logic goes here.
    }
 }
 List<Car> cars = getCars();
 cars = Collections.sort(cars, carComparator); //the cars collection is now sorted.

If you wanted to sometimes sort by one attribute or another, you could make my variable carComparator into its own class and define which attributes to sort by in the constructor.

Hope that helps :)

Edit: As others have pointed out, this approach also works with arrays. But unless you have a good reason to be working with Arrays, working with Collections will generally be easier.

Answer 2

I think the solution would be more efficient if you passed a Comparator implementation to the Arrays.sort. Right now, you are looping n*2 from the looks of it, the hash map (O(1)) plus the Arrays.sort (which is another 0(n log n) or such). If you do the below, you could skip the 2 loops, and the map, you are using currently.

You can simply create a Comparator like (rough code):

class CarComparator implements Comparator<Car> {
    enum compareType; //plus setter

    public int compareTo(Car a, Car b) {
        if(compareType == COLOUR) return a.colour.compareTo(b.colour);
        if(compareType == NAME.....
    }
}

, and then simply send the array of Cars to

Arrays.sort(cars, new CarComparator(COLOUR))

, or use more specialised comparator classes, one for each attribute, and a factory to render them, and of course don't create a new Comparator() for each sort if this is happening often. :-)

Overall, this approach should make your code more efficient. }

Answer 3

It would be much simpler to use custom comparators:

To sort by name:

Arrays.sort(carArray, Comparator.comparing(Car::name));

To sort by colour:

Arrays.sort(carArray, Comparator.comparing(Car::colour));

So you could modify getSortedArray():

public static Car[] getSortedArray(Car[] carArray, Comparator<Car> comparator) {
    Car[] sorted = carArray.clone()
    Arrays.sort(sorted, comparator);
    return sorted;
}

And call it like this:

Car[] sorted = getSortedArray(carArray, Comparator.comparing(Car::name));

Edit:

If you use a language version that does not support these features, you can create the comparators by explicitly creating a nested class that implements the Comparator interface.

This, for example, is a singleton Comparator that compares Car instances by name:

static enum ByName implements Comparator<Car> {
    INSTANCE;

    @Override
    public int compare(Car c1, Car c2) {
        return c1.name().compareTo(c2.name());
    }
}

Then call:

Car[] sorted = getSortedArray(carArray, ByName.INSTANCE);

Answer 4

TL;DR: There's already a wheel for that.

I would say the easiest way to do this is to create a comparator:

final Comparator<Car> byName = Comparator.comparing(Car::name);
final Comparator<Car> byColour = Comparator.comparing(Car::colour);

Then just use the appropriate method on Arrays to sort by a comparator:

Arrays.sort(carArray, byName);

Now you want to do it with an enum? Just have the enum implements Comparator<Car>:

enum SortBy implements Comparator<Car> {
    NAME(Comparator.comparing(Car::name)),
    COLOUR(Comparator.comparing(Car::colour));

    private final Comparator<Car> delegate;

    private SortBy(Comparator<Car> delegate) {
        this.delegate = delegate;
    }

    @Override
    public int compare(final Car o1, final Car o2) {
        return delegate.compare(o1, o2);
    }               
}

Want to sort by name then by colour? Easy:

final Comparator<Car> byName = SortBy.NAME.thenComparing(SortBy.COLOUR);

Want to sort by name in reverse order? Easy:

final Comparator<Car> byName = SortBy.NAME.reversed();