Question: I need a comparator as part of a strategy pattern that can either use the natural ordering of the objects or some custom ordering. For the natural ordering case, I wrote a simple comparator:

```
private static class NaturalComparator<T extends Comparable<? super T>> implements Comparator<T> {
    @Override
    public int compare(T o1, T o2) {
        return o1.compareTo(o2);
    }
}

```

Seems simple enough, but I was wondering if anyone knew of one in the standard API. I looked at TreeMap, and it does it without such a class, so when that code was written, the apparent answer would be no, but perhaps it was added later.

Answer: 
Added to [Comparator in Java 8](https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html#naturalOrder--):

```
static <T extends Comparable<? super T>> Comparator<T> naturalOrder()

```

Use it like this, for example:

```
Comparator<Double> natural = Comparator.<Double>naturalOrder();
return natural.compare(1.0, 1.1));

```
I am not familiar with a default comparator in Java, but obviously, Comparator to compareTo is often a mere wrapper. 

There is no general of "natural ordering" in the standard API, although certain built in types, like numbers, have an implementation of compareTo which then becomes their natural ordering. 

`TreeMap` and `TreeSet` and all these should throw a RuntimeException if the object you put in does not implement Comparable. Thus, for example, you could throw in strings or numbers but not another collection. 

The code of `TreeMap` does not use a comparator if one is not available - it uses `compareTo` instead. To use `compareTo`, it does a cast to `Comparable`, which is the source of the exceptions.

```
    private int compare(K k1, K k2) {
      return (comparator==null ? ((Comparable <K>)k1).compareTo(k2)
                                : comparator.compare((K)k1, (K)k2));
  }

```