是否可以使用Comparator <T>实现reverseOrder（）方法？

Question

I have been analyzing with Comparator interface in Java SE 8. Now, I am interested to know that how could I use reverseOrder() method using a class which implements the Comparator<T> interface. I wrote to a example program to check that out.

class NaturalOrderString implements Comparator<String>{
    @Override
    public int compare(String o1, String o2) {
        // TODO Auto-generated method stub
        return o1.compareTo(o2);
    }               
} 

public class App {
  public static void main(String[] args) { 
      Comparator<String> mycom= new NaturalOrderString();

      mycom.reverseOrder(); // can't use this
   }
}

So, now I should be able to use all the methods associated with Comparator Interface. But surprisingly whey I type mycom. then there comes no suggestion for reverseOrder() method. Why ? The class NaturalOrderString implements Comparator<T> .

So, I should accept mycom object to access reverseOrder() method. Isn't it ?

Moreover, I came to know that sorting in lists are occurred using natural ordering . So, using the Collection class I could access reverseOrder() method. So, preceding my example I could happily write

Collections.reverseOrder(mycom); // that's fine.

But my question is why I can't use reverseOrder() using a object of a class which implements Comparator<T> ? And, since we can't access it why Java include reverseOrder() method in Comparator<T> interface ?

Or, if it's really possible to access reverseOrder() through mycom object regarding my code, please give me an example of it.

Answer 1

Basically a lot of magic is possible here.

In order to reverse sorting, you simply need to "reverse" the result of the comparation.

You can study these foils . They are written in German, but there isn't much text there - and the code is all java. The presentation gives some lambda basics; to then explain how you can use lambdas and method references to develop a whole system where you sort/reverse sort streams; using "accessor" objects to retrieve whatever properties from the things you intend to sort.

For example leading to:

interface Comparator<T> {
  public int compare(T a, T b);
  public default Comparator<T> reversed() {
    return (a, b) –> compare(b, a) ;
}

Now one can implement that interface, and reverse sorting comes for free.

Answer 2

The Comparator.reverseOrder() method simply delegates to Collections.reverseOrder() and Collections.reverseOrder() simply returns a comparator which implements reverse natural ordering.

What you are trying to do is as simple as this:

@Override
public int compare(String o1, String o2) 
{
    int d = o1.compareTo(o2);
    return -d;

which can also be achieved with myComparator.reversed() .

Answer 3

Basically reverseOrder() method will return a comparator that imposes the reverse of the natural ordering.

Firstly, following your question, since reverseOrder() is a static method you can't use it like mycom.reverseOrder(). You have to use like Comparot.reverseOrder(). Following your code. I created a ArrayList to demonstrate and use Comparator.reverseOrder()

public class App {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    List<String> people= new ArrayList<String>();
    people.add("Sam");
    people.add("Bob");
    people.add("Andrew");
    people.add("Michel");
    people.add("Abe");
    people.add("John");

    Comparator<String> mycom= new NaturalOrderString();

    Collections.sort(people); // this will sort the people array list in natural order

    Collections.sort(people,Comparator.reverseOrder()); // Here's your desired method it will reverse the natural order as documentation.

     }
  }

Hope you are now clear with this concept.

Answer 4

Because Comparator.reverseOrder is a static method.

From the JLS :

[8.4.8] A class does not inherit static methods from its superinterfaces.

If you want to use this method, you can just call it as Comparator.reverseOrder() . However, it sounds like that's not what you actually want - use the non-static reversed() instead.

Answer 5

Can I use Comparator.reverseOrder()

Yes, of course you can. It's just not immediately obvious how you might use it because the compiler infers a lot of information.

The signature is:

static <T extends Comparable<? super T>> Comparator<T> reverseOrder()

So as you can see, it takes a generic type, which must implement Comparable . It's somewhat more strict than that: it requires the type to be comparable to either itself or one of its super types. We couldn't get a reverse comparator for Apple, using these definitions:

public class Orange { }
public class Apple implements Comparable<Orange> { /* methods */ }

reverseOrder takes no arguments but returns us a Comparator of the type we pass in. You can use it like so:

Comparator<Foo> reverseCompatator = Comparator.<Foo>reverseOrder();

Here's a full, compilable example:

// Simply wraps an integer value
class Foo implements Comparable<Foo>
{
    private final Integer value;

    Foo(final Integer value) {
        this.value = value;
    }

    public int compareTo(Foo that) {
        // use standard integer comparison (i.e. 1,2,3,4,5,...)
        return this.value.compareTo(that.value);
    }

    @Override
    public String toString() {
        return "Foo " + value;
    }
}

public class Main
{
    public static void main (String[] args)
    {
        // create a list
        List<Foo> foos = Arrays.asList(new Foo(1), new Foo(3), new Foo(5));

        // sort the list in reverse
        foos.sort(
            Comparator.<Foo>reverseOrder()
        );

        System.out.println(foos);
    }
}

Sample output:

[Foo 5, Foo 3, Foo 1]

In practice you can remove <Foo> from Comparator.<Foo> because the compiler is able to work out what you need.