Multiple instances of Comparable Interface / compareTo in a class

Programming Questions

colinowens

Multiple instances of Comparable Interface / compareTo in a class

in Programming Questions • 1 year ago

Hello all,
I've used an instance of the Comparable interface in my class to reorder the object by id and I'm wondering if it's possible to resort the object by other criteria (such as date) by using two instances of the interface.

My apologies ahead of time if this is a bit of a JAVA newb question. I'm still getting the hang of diving deeper into the language from Processing. Example of what I'm doing below (I believe Comparable's been discussed before in this forum but not asked about like this):

public class Joe implements Comparable {
...

int compareTo(Object o)
{
    Joe other=(Joe)o;
    if (other.id>id)
      return -1;
    if (other.id==id)
      return 0;
    else
      return 1;
}
...

Replies(2)

PhiLho

Re: Multiple instances of Comparable Interface / compareTo in a class

1 year ago

Well, basically you can have a class variable indicating what is the criterion for the current comparison. Then compareTo can select which variables to use in the comparison, depending on this variable.
Something like:
if (bByIde) {
return id - other.id;
} else if (bBySize) {
// Compare...
} // Etc.

But honestly, it is a bit messy. Such case is quite common (eg. comparing persons: can be by age, by size, by number of children, whatever) so Java offers the Comparator interface: it allows to offer a comparison function to the sort function itself, instead of building it in the object itself.

I quickly made a demo to illustrate both methods of sorting:

class Foo implements Comparable<Foo> // Tells this class has a natural order
{
  int id;
  float size;
  int quantity;
  
  // Constructor
  Foo(int i, float s, int q)
  {
    id = i;
    size = s;
    quantity = q;
  }
  
  // To display nicely the objects
  public String toString() { return id + " " + nf(size, 2, 2) + " " + quantity; }
  
  // Natural order
  public int compareTo(Foo f)
  {
      // Beware of overflows with this kind of comparison!
      // Here, we know it is OK as we control the scope of the values
      return id - f.id;
  }
}
 
void setup()
{
  Foo[] foos = new Foo[10];
  for (int i = 0; i < foos.length; i++)
  {
    foos[i] = new Foo(i, random(1.0, 20.0), int(random(100)));
  }
  
  // Sort by quantity
  Arrays.sort(foos, new Comparator<Foo>()
  {
    public int compare(Foo f1, Foo f2)
    {
      if (f1.size > f2.size) return 1;
      if (f1.size < f2.size) return -1;
      return 0;
    }
  });
  println("By size");
  println(foos);
  
  // Resort by quantity, in descending order
  Arrays.sort(foos, new Comparator<Foo>()
  {
    public int compare(Foo f1, Foo f2)
    {
      return f2.quantity - f1.quantity;
    }
  });
  println("By quantity");
  println(foos);
   
  // Resort by id, in natural order
  Arrays.sort(foos); // No need for a Comparator here
  println("By id");
  println(foos);
  
  exit();
}

colinowens

Re: Multiple instances of Comparable Interface / compareTo in a class

1 year ago

PhiLo, that did the trick. I further classed the sorting based on this JAVA example. The exception handling may be a little heavy handed, but may come in handy after a long nights coding.

I noticed that you had a copy of Scott McCloud's Understanding Comics on your Amazon Wish list. I hope you enjoy ;)

Thing[] thing = new Thing[10];
void setup() {
for (int i = 0;i < thing.length;i++) {
thing[i] = new Thing();
thing[i].setID(int(random(0,50)));
thing[i].setDate (int(random(1000,2000)));
}

// The natural order

println("not sorted");
for (int i = 0;i < thing.length;i++) {
    println(thing[i].id + " " + thing[i].date);
}
println();

// Sort it by ID

println("sorted by id");
Arrays.sort(thing, new IdComparator());

for (int i = 0;i < thing.length;i++) {
    println(thing[i].id + " " + thing[i].date);
}
println();

// Sort if by Date

println("sorted by date");
Arrays.sort(thing, new DateComparator());

for (int i = 0;i < thing.length;i++) {
    println(thing[i].id + " " + thing[i].date);
}
}

void draw() {
}

class Thing implements Comparable {
int id;
int date;
public Thing() {
}
public int getId() {
    return id;
}
public int date() {
    return id;
}
public void setID(int id) {
    this.id = id;
}
public void setDate(int date) {
    this.date = date;
}
public int compareTo(Object anotherThing) throws ClassCastException {
    if (!(anotherThing instanceof Thing))
      throw new ClassCastException("A Thing object expected.");
    int anotherThingId = ((Thing) anotherThing).getId();
    return this.id - anotherThingId;
}
}

public class IdComparator implements Comparator {
int compare(Object o, Object p)
{
    Thing o1=(Thing)o;
    Thing p1=(Thing)p;
    if (o1.id>p1.id)
      return 1;
    if (o1.id==p1.id)
      return 0;
    else
      return -1;
}
}

public class DateComparator implements Comparator {
int compare(Object o, Object p)
{
    Thing o1=(Thing)o;
    Thing p1=(Thing)p;
    if (o1.date>p1.date)
      return 1;
    if (o1.date==p1.date)
      return 0;
    else
      return -1;
}
}

Top Reply