Very confused by Java 8 Comparator type inference

by

First, all the examples you say cause errors compile fine with the reference implementation (javac from JDK 8.) They also work fine in IntelliJ, so its quite possible the errors you’re seeing are Eclipse-specific.

Your underlying question seems to be: “why does it stop working when I start chaining.” The reason is, while lambda expressions and generic method invocations are poly expressions (their type is context-sensitive) when they appear as method parameters, when they appear instead as method receiver expressions, they are not.

When you say

Collections.sort(playlist1, comparing(p1 -> p1.getTitle()));

there is enough type information to solve for both the type argument of comparing() and the argument type p1. The comparing() call gets its target type from the signature of Collections.sort, so it is known comparing() must return a Comparator<Song>, and therefore p1 must be Song.

But when you start chaining:

Collections.sort(playlist1,
                 comparing(p1 -> p1.getTitle())
                     .thenComparing(p1 -> p1.getDuration())
                     .thenComparing(p1 -> p1.getArtist()));

now we’ve got a problem. We know that the compound expression comparing(...).thenComparing(...) has a target type of Comparator<Song>, but because the receiver expression for the chain, comparing(p -> p.getTitle()), is a generic method call, and we can’t infer its type parameters from its other arguments, we’re kind of out of luck. Since we don’t know the type of this expression, we don’t know that it has a thenComparing method, etc.

There are several ways to fix this, all of which involve injecting more type information so that the initial object in the chain can be properly typed. Here they are, in rough order of decreasing desirability and increasing intrusiveness:

  • Use an exact method reference (one with no overloads), like Song::getTitle. This then gives enough type information to infer the type variables for the comparing() call, and therefore give it a type, and therefore continue down the chain.
  • Use an explicit lambda (as you did in your example).
  • Provide a type witness for the comparing() call: Comparator.<Song, String>comparing(...).
  • Provide an explicit target type with a cast, by casting the receiver expression to Comparator<Song>.

More Related Contents:

  1. Comparator.reversed() does not compile using lambda
  2. Reverse a comparator in Java 8
  3. Comparator.comparing(…) of a nested field
  4. java: Arrays.sort() with lambda expression
  5. Group sequences of values
  6. Difference between final and effectively final
  7. How to use Comparator in Java to sort
  8. Java 8 lambdas, Function.identity() or t->t
  9. Sorting Java objects using multiple keys
  10. Break or return from Java 8 stream forEach?
  11. Lambda Expression and generic defined only in method
  12. Reflection type inference on Java 8 Lambdas
  13. Java 8 Lambda Expressions – what about multiple methods in nested class
  14. Filter values only if not null using lambda in Java8
  15. Retrieving a List from a java.util.stream.Stream in Java 8
  16. Java8: ambiguity with lambdas and overloaded methods
  17. null-safe mapping Comparator using default implementations
  18. How do I use the new computeIfAbsent function?
  19. Java8 Lambdas and Exceptions
  20. Why can method reference use non-final variables?
  21. Possibility to explicit remove Serialization support for a lambda
  22. How to make a lambda expression define toString in Java 8?
  23. Java 8 grouping using custom collector?
  24. How can I throw CHECKED exceptions from inside Java 8 lambdas/streams?
  25. How to apply multiple predicates to a java.util.Stream?
  26. Parallel stream from a HashSet doesn’t run in parallel
  27. Non-interference exact meaning in Java 8 streams
  28. Sorting a List in parallel without creating a temporary array in Java 8
  29. Cannot use Java 8 method with lambda arguments without specifying type arguments
  30. Creating String representation of lambda expression [duplicate]

Leave a Comment