4

In Effective Java, in the item "Use bounded wildcards to increase API flexibility", when talking about the usage of PECS (producer-extends, consumer-super), the author mentioned that:

Comparables are always consumers, so you should generally use Comparable<? super T> in preference to Comparable. The same is true of comparators; therefore, you should generally use Comparator<? super T> in preference to Comparator.

It is not clear to me why Comparables and Comparators are considered consumers.

In one of the topic discussing PECS, What is PECS (Producer Extends Consumer Super)?, the consumer is usually referring to a Collection as a parameter for some generic method.

While here Comparable is just an interface.

Can anyone share some insights? Thanks!

cxs1031
  • 150
  • 2
  • 9
  • 5
    They are consumers because the generic methods (`compareTo(T)` for `Comparable` and `compare(T, T)` for `Comparator`) take in (i.e. **consume**) `T`'s. For the collections, it depens whether your store `T`s in the collection (i.e. the `Collection` **consumes** `T`s) or retrieving `T`s from the collection (i.e. the `Collection` **produces** `T`s). – Turing85 Aug 12 '20 at 22:06

3 Answers3

5

A nice analogy can be drawn to the interfaces Consumer<T> and Supplier<T> (with Supplier being analogous to Producer). A Consumer<T> is a function that takes in a T, while a Supplier<T> is a function that returns a T. Notice that we are talking about method signatures and return type, we say nothing about the semantics of the method. This is a core property of PECS: it is independent of the semantics and can be determined solely on the signature and return type of the methods used.

Looking at Comparable<T> and Comparator<T>, we find that both have methods (int compareTo(T) and int compare(T, T)) that take in, i.e. consume, T's.

For the collections, we have to look on how we use the collection, i.e. if we are using producer- or consumer-methods:

  • If we retrieve data from the collection (T get(int), iterator, ...), the list produces values for us and we use ? extends T.
  • If we use the collection to store data, (i.e. we call add(T), addAll(Collection<T>), contains(T), ...), we call consuming methods, thus the method is a consumer of our data and we use ? super T.
  • If we use a collection to both store and retrieve values, the collection acts as a consumer and producer at the same time, thus we have to use the precise T, neither using ... extends ... nor ... super ....
Turing85
  • 18,217
  • 7
  • 33
  • 58
3

„…It is not clear to me why Comparables and Comparators are considered consumers.…“

Anytime a method member of a generic class C<T>, takes in (i.e. „consumes“) an argument that is of type T, then that method is a consumer of Ts.

So Comparator<T>.compareTo(T o) is said to be a „consumer“ of the o object of the type represented by the type variable T.

deduper
  • 1,944
  • 9
  • 22
3

When we say "Comparable is a consumer", we actually mean "the method of the interface is a consumer". This is an answer to your doubt that "Comparable is just an interface."

See its signature: https://docs.oracle.com/en/java/javase/14/docs/api/java.base/java/lang/Comparable.html#compareTo(T)

int compareTo​(T o)

It consumes the generic T, it does not produce any generic object.

Honza Zidek
  • 9,204
  • 4
  • 72
  • 118