Comparable interface problem

[Mohit G Gupta]

KB book page-573,574
topic Sorting with Comparator

The other handy thing about
the Comparator interface is that you can use it to sort instances of any class—even
classes you can't modify—unlike the Comparable interface, which forces you to
change the class whose instances you want to sort.

i just cannot understand that while using Comparable interface how are we changing the class
for instance:

 

Putting it all together, our DVDInfo class should now look like this:
class DVDInfo implements Comparable<DVDInfo> {
  String title;
  String genre;
  String leadActor;
  DVDInfo(String t, String g, String a) {
    title = t;  genre = g;  leadActor = a;
  }
  public String toString() {
    return title + " " + genre + " " + leadActor + "\n";
  }
  public int compareTo(DVDInfo d) {    
    return title.compareTo(d.getTitle());  
  }
  public String getTitle() {
    return title;
  }
  // other getters and setters
}

   

IN The compareTo function definition in DVDInfo ,only the compareTo function is called with DVDInfo objects.now,where are we changing the class.

[Christophe Verré]

Please ShowSomeEffort. You can find a lot of tutorials showing you how the Comparable and Comparator interfaces work.

[Mohit G Gupta]

sorry Christophe.
i have updated my query

[Christophe Verré]

You already know that you can use easy Comparable or Comparator to sort your DVDInfo. If you use the Comparable interface, you have to change the DVDInfo class, by implementing the Comparable interface and its compareTo method. However, if you use a Comparator, you don't need to touch your DVDInfo class. This is more flexible, because you can make as many comparators as you want.

class DVDInfo {
  String title;
  String genre;
  String leadActor;
  DVDInfo(String t, String g, String a) {
    title = t;  genre = g;  leadActor = a;
  }
  public String toString() {
    return title + " " + genre + " " + leadActor + "\n";
  }
  
  public String getTitle() {
    return title;
  }
  // other getters and setters
}

List<DVDInfo> dvdList = new ArrayList<DVDInfo>();
...
Collections.sort(dvdList, new Comparator<DVDInfo>() {
	int compare(DVDInfo o1, DVDInfo o2) {
		...
	}
	
	boolean equals(Object obj) {
		...
	}
});

[Kevin Kilbane]

mohitkumar gupta wrote:The other handy thing about
the Comparator interface is that you can use it to sort instances of any class—even
classes you can't modify—unlike the Comparable interface, which forces you to
change the class whose instances you want to sort.

i just cannot understand that while using Comparable interface how are we changing the class

Say you have 2 String objects that you want to compare. String implements Comparable which means it has a compareTo method that compares Strings alphabetically so "Apple" comes before "Bed" which comes before "Cork".

Say, for whatever reason, in your program that you want Strings to be ordered by the length of the String i.e. "Bed" (3 characters) comes before "Cork" (4 characters) which comes before "Apple" (5 characters).

You do not have access to the String class - you can't modify the compareTo method of String.java.

But you can write a new class

class StringLengthComparator implements Comparator<String>  {

    public int compare(String s1, String s2) {
        return(s1.length - s2.length);
    }
}

Hoever, if you have objects of your own class you want to compare - you can do it by modifying your own class:

class MyClass implements Comparable {
    int age;

    public int compare(MyClass mc) {
        return this.age - mc.age;
    }
}

So in the first example you didn't modify the class you wanted to compare (String class) but in the second example, you could modify it (MyClass class).

[Mohit G Gupta]

i have understood what you are trying to say

       class StringLengthComparator implements Comparator<String>  {  
  
   public int compare(String s1, String s2) {  
         return(s1.length - s2.length);  
      }  
  }   

but ,i think return of the compare function should be

    
s1.length.compareTo(s2.length);

and in the second case when the comparable interface is implemented,the function to be used should be

   
  public int compareTo(MyClass mc) {  
        return  age.compareTo(mc.age);  
    }  
 

[Kevin Kilbane]

mohitkumar gupta wrote:i have understood what you are trying to say

       class StringLengthComparator implements Comparator<String>  {  
  
   public int compare(String s1, String s2) {  
         return(s1.length - s2.length);  
      }  
  }   

but ,i think return of the compare function should be

    
s1.length.compareTo(s2.length);

and in the second case when the comparable interface is implemented,the function to be used should be

   
  public int compareTo(MyClass mc) {  
        return  age.compareTo(mc.age);  
    }  
 

Incorrect I'm afraid.

s1.length and age are both ints so you they don't have compareTo methods to call (they don't have ANY methods to call).

Even if s1.length and age weren't ints, if they were objects of some type, it doesn't necessarily mean you have to use (s1 and age's) compareTo methods within the compare / compareTo methods (of StringLengthComparator and MyClass). It depends totally on the design of your program and what attributes of an object you need to sort on.

[Mohit G Gupta]

1. class MyClass implements Comparable {
2. int age;
3.
4. public int compare(MyClass mc) {
5. return this.age - mc.age;
6. }
7. }

compare function takes two arguments and not one as mentioned in java API.
i think the compare function definition is wrong

[Kevin Kilbane]

mohitkumar gupta wrote:

1. class MyClass implements Comparable {
2. int age;
3.
4. public int compare(MyClass mc) {
5. return this.age - mc.age;
6. }
7. }

compare function takes two arguments and not one as mentioned in java API.
i think the compare function definition is wrong

That is correct but a class that implements Comparable should over-write compareTo, not compare. My example above is wrong, it should have read:

class StringLengthComparator implements Comparator<String>  {  

    public int compare(String s1, String s2) {  
        return(s1.length - s2.length);  
    }  
}  


class MyClass implements Comparable {  
    int age;  
  
    public int compareTo(MyClass mc) {     // comapreTo, not compare
        return this.age - mc.age;  
    }  
}

Apologies for confusion