java comparator, how to sort by integer?

Question

Im trying to learn comparator in java and I have found this great example online, my question is how would this code be changed so that the pet names are ordered by age and in descending order so that the oldest is first and youngest is last?

class Dog implements Comparator<Dog>, Comparable<Dog>{
private String name;
private int age;
Dog(){
}

Dog(String n, int a){
  name = n;
  age = a;
}

public String getDogName(){
  return name;
}

public int getDogAge(){
  return age;
}

// Overriding the compareTo method
public int compareTo(Dog d){
  return (this.name).compareTo(d.name);
}

// Overriding the compare method to sort the age 
public int compare(Dog d, Dog d1){
  return d.age - d1.age;
}
}

public class Example{
public static void main(String args[]){
  // Takes a list o Dog objects
  List<Dog> list = new ArrayList<Dog>();

  list.add(new Dog("Shaggy",3));
  list.add(new Dog("Lacy",2));
  list.add(new Dog("Roger",10));
  list.add(new Dog("Tommy",4));
  list.add(new Dog("Tammy",1));
  Collections.sort(list);// Sorts the array list

  for(Dog a: list)//printing the sorted list of names
     System.out.print(a.getDogName() + ", ");

  // Sorts the array list using comparator
  Collections.sort(list, new Dog());
  System.out.println(" ");
  for(Dog a: list)//printing the sorted list of ages
     System.out.print(a.getDogName() +"  : "+
     a.getDogAge() + ", ");
}
}

This certainly is not a good example, using one dog to compare the ages of two others is incredibly bad design. It doesn't matter whether this is just a small example of how this can work. It gives people wrong ideas on how to properly implement these interfaces. — Cephalopod
– Cephalopod, Commented May 22, 2012 at 21:00

Jeshurun · Accepted Answer · 2018-03-23 16:13:27Z

104

Simply changing

public int compare(Dog d, Dog d1) {
  return d.age - d1.age;
}

to

public int compare(Dog d, Dog d1) {
  return d1.age - d.age;
}

should sort them in the reverse order of age if that is what you are looking for.

Update:

@Arian is right in his comments, one of the accepted ways of declaring a comparator for a dog would be where you declare it as a public static final field in the class itself.

class Dog implements Comparable<Dog> {
    private String name;
    private int age;

    public static final Comparator<Dog> DESCENDING_COMPARATOR = new Comparator<Dog>() {
        // Overriding the compare method to sort the age
        public int compare(Dog d, Dog d1) {
            return d.age - d1.age;
        }
    };

    Dog(String n, int a) {
        name = n;
        age = a;
    }

    public String getDogName() {
        return name;
    }

    public int getDogAge() {
        return age;
    }

    // Overriding the compareTo method
    public int compareTo(Dog d) {
        return (this.name).compareTo(d.name);
    }

}

You could then use it any where in your code where you would like to compare dogs as follows:

// Sorts the array list using comparator
Collections.sort(list, Dog.DESCENDING_COMPARATOR);

Another important thing to remember when implementing Comparable is that it is important that compareTo performs consistently with equals. Although it is not required, failing to do so could result in strange behaviour on some collections such as some implementations of Sets. See this post for more information on sound principles of implementing compareTo.

Update 2: Chris is right, this code is susceptible to overflows for large negative values of age. The correct way to implement this in Java 7 and up would be Integer.compare(d.age, d1.age) instead of d.age - d1.age.

Update 3: With Java 8, your Comparator could be written a lot more succinctly as:

public static final Comparator<Dog> DESCENDING_COMPARATOR = 
    Comparator.comparing(Dog::getDogAge).reversed();

The syntax for Collections.sort stays the same, but compare can be written as

public int compare(Dog d, Dog d1) {
    return DESCENDING_COMPARATOR.compare(d, d1);
}

edited Mar 23, 2018 at 16:13

answered May 22, 2012 at 20:42

Jeshurun

23.2k6 gold badges82 silver badges92 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Christopher Schultz Over a year ago

It's unlikely to represent a problem, here, but this comparator has an integer overflow/underflow bug in it. If the dogs ages are Integer.MIN_VALUE and any positive integer (or Integer.MAX_VALUE and any negative number), you'll get wrap-around and the sort order will be unexpected. It seems silly, but this is something I think programmers should be thinking about, even when comparing dogs' ages. Try using Integer.compare (and other similar methods in other java.lang.Number subclasses) instead of performing your own subtraction.

Croo Over a year ago

comment for the Update 3 Java 8 solution:to compare age you have to use comparingInt instead of comparing.

Rory McCrossan · Accepted Answer · 2015-05-13 08:09:50Z

31

public class DogAgeComparator implements Comparator<Dog> {
    public int compare(Dog o1, Dog o2) {
        return Integer.compare(o1.getAge(), o2.getId());
    }
}

edited May 13, 2015 at 8:09

Rory McCrossan

338k41 gold badges321 silver badges353 bronze badges

answered May 13, 2015 at 7:49

George Thekkan

4117 silver badges10 bronze badges

4 Comments

abarisone Over a year ago

Could you please elaborate more your answer adding a little more description about the solution you provide?

S.L. Barth is on codidact.com Over a year ago

I suppose you mean Integer.compare(o1.getDogAge(), o2.getDogAge())? OP's Dog class doesn't have a getAge, and subtracting ID from age doesn't make sense.

Stoycho Andreev Over a year ago

this code required min API level 19 because of Integer.compare(o1.getAge(), o2.getId()). If you want to use it in lower API levels you can use o1.getAge() - o2.getAge() instade

George Thekkan Over a year ago

my mistake, return Integer.compare(o1.getAge(), o2.getAge());

jota3 · Accepted Answer · 2019-02-14 21:12:04Z

29

From Java 8 you can use :

Comparator.comparingInt(Dog::getDogAge).reversed();

edited Feb 14, 2019 at 21:12

answered Apr 19, 2017 at 13:59

jota3

5,8262 gold badges15 silver badges23 bronze badges

Comments

elias · Accepted Answer · 2012-05-22 21:27:25Z

22

Just replace:

return d.age - d1.age;

By:

return ((Integer)d.age).compareTo(d1.age);

Or invert to reverse the list:

return ((Integer)d1.age).compareTo(d.age);

EDIT:

Fixed the "memory problem".
Indeed, the better solution is change the age field in the Dog class to Integer, because there many benefits, like the null possibility...

edited May 22, 2012 at 21:27

answered May 22, 2012 at 20:43

elias

15.6k4 gold badges45 silver badges66 bronze badges

4 Comments

Has QUIT--Anony-Mousse Over a year ago

At the cost of unneccesarily creating objects. Don't do this for large data sets when you hav to sort a lot. In particular, since the alternative is much simpler...

Cephalopod Over a year ago

At least use Integer.valueOf() instead of new

McIntosh Over a year ago

Why not simply use return Integer.compare(d.age, d1.age);? Is available since Java 7

Jan Rabe Over a year ago

Integer.compare on android requires api >= 19

Dunes · Accepted Answer · 2012-05-22 21:08:36Z

One simple way is

Comparator<Dog> ageAscendingComp = ...;
Comparator<Dog> ageDescendingComp = Collections.reverseOrder(ageAscendingComp);
// then call the sort method

On a side note, Dog should really not implement Comparator. It means you have to do strange things like

Collections.sort(myList, new Dog("Rex", 4));
// ^-- why is a new dog being made? What are we even sorting by?!
Collections.sort(myList, myList.get(0));
// ^-- or perhaps more confusingly

Rather you should make Compartors as separate classes.

eg.

public class DogAgeComparator implments Comparator<Dog> {
    public int compareTo(Dog d1, Dog d2) {
        return d1.getAge() - d2.getAge();
    }
}

This has the added benefit that you can use the name of the class to say how the Comparator will sort the list. eg.

Collections.sort(someDogs, new DogNameComparator());
// now in name ascending order

Collections.sort(someDogs, Collections.reverseOrder(new DogAgeComparator()));
// now in age descending order

You should also not not have Dog implement Comparable. The Comparable interface is used to denote that there is some inherent and natural way to order these objects (such as for numbers and strings). Now this is not the case for Dog objects as sometimes you may wish to sort by age and sometimes you may wish to sort by name.

olen_garn · Accepted Answer · 2016-08-15 23:24:07Z

3

If you have access to the Java 8 Comparable API, Comparable.comparingToInt() may be of use. (See Java 8 Comparable Documentation).

For example, a Comparator<Dog> to sort Dog instances descending by age could be created with the following:

Comparable.comparingToInt(Dog::getDogAge).reversed();

The function take a lambda mapping T to Integer, and creates an ascending comparator. The chained function .reversed() turns the ascending comparator into a descending comparator.

Note: while this may not be useful for most versions of Android out there, I came across this question while searching for similar information for a non-Android Java application. I thought it might be useful to others in the same spot to see what I ended up settling on.

answered Aug 15, 2016 at 23:24

olen_garn

9027 silver badges16 bronze badges

1 Comment

swaroop Over a year ago

it is not Comparable.comparingToInt(), please edit to Comparator.comparingToInt(...)

Collectives™ on Stack Overflow

java comparator, how to sort by integer?

6 Answers 6

2 Comments

4 Comments

Comments

4 Comments

Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

2 Comments

4 Comments

Comments

4 Comments

Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related