min by doesn't compile? (Sybex)

[Mihaela Hetea]

The last example from chapter 4, "Collecting Using Grouping, Partitioning, and Mapping" does not compile:

Stream<String> ohMy = Stream.of("lions", "tigers", "bears"); Map<Integer, 
Optional<Character>> map = ohMy.collect(
   Collectors.groupingBy(
      String::length,
      Collectors.mapping(s -> s.charAt(0),
         Collectors.minBy(Comparator.naturalOrder()))));
System.out.println(map); // {5=Optional[b], 6=Optional[t]}

The problem seems to be with the minBy collector. I'm using IntelliJ with java version 1.8.0_45

[Jeanne Boyarsky]

Mihaela Hetea wrote:The last example from chapter 4, "Collecting Using Grouping, Partitioning, and Mapping" does not compile:

It works for me both in Eclipse at the command line using Mac and Eclipse. Both with Java 1.8.0_45.

Here's the exact file I tested with:

import java.io.*;
import java.util.*;
import java.util.stream.*;

public class PlayTest {

	public static void main(String[] args) throws IOException {

		Stream<String> ohMy = Stream.of("lions", "tigers", "bears"); Map<Integer, 
		Optional<Character>> map = ohMy.collect(
		   Collectors.groupingBy(
		      String::length,
		      Collectors.mapping(s -> s.charAt(0),
		         Collectors.minBy(Comparator.naturalOrder()))));
		System.out.println(map); // {5=Optional[b], 6=Optional[t]}
	}
}

What compiler error do you get?

[Paweł Baczyński]

I tried to compile this using javac 1.8.0_40.

The output is:

PlayTest.java:11: error: no suitable method found for groupingBy(String::length,Collector<Object,CAP#1,Optional<T#1>>)
           Collectors.groupingBy(
                     ^
    method Collectors.<T#3,K#1>groupingBy(Function<? super T#3,? extends K#1>) is not applicable
      (cannot infer type-variable(s) T#3,K#1
        (actual and formal argument lists differ in length))
    method Collectors.<T#4,K#2,A#1,D#1>groupingBy(Function<? super T#4,? extends K#2>,Collector<? super T#4,A#1,D#1>) is not applicable
      (inferred type does not conform to upper bound(s)
        inferred: Object
        upper bound(s): T#5,Comparable<? super T#5>,Object)
    method Collectors.<T#6,K#3,D#2,A#2,M>groupingBy(Function<? super T#6,? extends K#3>,Supplier<M>,Collector<? super T#6,A#2,D#2>) is not applicable
      (cannot infer type-variable(s) T#6,K#3,D#2,A#2,M
        (actual and formal argument lists differ in length))
  where T#1,T#2,T#3,K#1,T#4,K#2,A#1,D#1,T#5,T#6,K#3,D#2,A#2,M are type-variables:
    T#1 extends T#2
    T#2 extends Comparable<? super T#2>
    T#3 extends Object declared in method <T#3,K#1>groupingBy(Function<? super T#3,? extends K#1>)
    K#1 extends Object declared in method <T#3,K#1>groupingBy(Function<? super T#3,? extends K#1>)
    T#4 extends Object declared in method <T#4,K#2,A#1,D#1>groupingBy(Function<? super T#4,? extends K#2>,Collector<? super T#4,A#1,D#1>)
    K#2 extends Object declared in method <T#4,K#2,A#1,D#1>groupingBy(Function<? super T#4,? extends K#2>,Collector<? super T#4,A#1,D#1>)
    A#1 extends Object declared in method <T#4,K#2,A#1,D#1>groupingBy(Function<? super T#4,? extends K#2>,Collector<? super T#4,A#1,D#1>)
    D#1 extends Object declared in method <T#4,K#2,A#1,D#1>groupingBy(Function<? super T#4,? extends K#2>,Collector<? super T#4,A#1,D#1>)
    T#5 extends Comparable<? super T#5> declared in method <T#5>naturalOrder()
    T#6 extends Object declared in method <T#6,K#3,D#2,A#2,M>groupingBy(Function<? super T#6,? extends K#3>,Supplier<M>,Collector<? super T#6,A#2,D#2>)
    K#3 extends Object declared in method <T#6,K#3,D#2,A#2,M>groupingBy(Function<? super T#6,? extends K#3>,Supplier<M>,Collector<? super T#6,A#2,D#2>)
    D#2 extends Object declared in method <T#6,K#3,D#2,A#2,M>groupingBy(Function<? super T#6,? extends K#3>,Supplier<M>,Collector<? super T#6,A#2,D#2>)
    A#2 extends Object declared in method <T#6,K#3,D#2,A#2,M>groupingBy(Function<? super T#6,? extends K#3>,Supplier<M>,Collector<? super T#6,A#2,D#2>)
    M extends Map<K#3,D#2> declared in method <T#6,K#3,D#2,A#2,M>groupingBy(Function<? super T#6,? extends K#3>,Supplier<M>,Collector<? super T#6,A#2,D#2>)
  where CAP#1 is a fresh type-variable:
    CAP#1 extends Object from capture of ?
PlayTest.java:13: error: cannot find symbol
              Collectors.mapping(s -> s.charAt(0),
                                       ^
  symbol:   method charAt(int)
  location: variable s of type Object
PlayTest.java:12: error: invalid method reference
              String::length,
              ^
  non-static method length() cannot be referenced from a static context
3 errors

Is there any bug that was fixed in _45?

[Mihaela Hetea]

This is the error I have too. Tried also with javac from command line but doesn't work either.
Tried also with java x86 1.8.0_45 and with java 1.8.0_71, same error.

[T Vergilio]

I get the same error, both from IntelliJ and from the command line. I have tried JDK 1.8.0_60 and the latest JDK 1.8.0_71 on Windows.

This is related to this thread.

[Piet Souris]

Works for me, on jdk1.8.0_65 NetBeans:

Stream<String> ohMy = Stream.of("lions", "tigers", "bears"); 
Map<Integer, Optional<Character>> map = 
    ohMy.collect(Collectors.groupingBy(
        s -> s.length(), Collectors.mapping(e -> e.charAt(0), 
                Collectors.minBy((c1, c2) -> c1.compareTo(c2)))
));

Output:

{5=Optional[b], 6=Optional[t]}

[T Vergilio]

Hi Piet,

But does it work if you replace

Collectors.minBy((c1, c2) -> c1.compareTo(c2)))

with

Collectors.minBy(Comparator.naturalOrder()))

[Piet Souris]

Hmmm... but not with Compare instead of (c1, c2) ->

[Piet Souris]

That would be: NO!

and I do not understand this; Java 8 bug?

[T Vergilio]

Looks like it

Funny how it will accept

Collectors.minBy(Comparable::compareTo))

which has a different signature!

[Piet Souris]

Well, your remark brings me to

Comparator<Character> comp = Comparator.naturalOrder();
Stream<String> ohMy = Stream.of("lions", "tigers", "bears"); 
Map<Integer, Optional<Character>> map = 
     ohMy.collect(Collectors.groupingBy(
        s -> s.length(), Collectors.mapping(e -> e.charAt(0), 
        Collectors.minBy(comp))
));

Works a treat!

[T Vergilio]

Indeed, how bizarre! It's looking more and more like a bug to me.

[Piet Souris]

Well, remarkable is that in

Comparator<Character> comp = Comparator.naturalOrder();

no type is specified in the right hand side of the assignment. It looks like the compiler
infers the type from the left hand side.

Now, if you use the RHS in the minBy(), could it be that the compiler cannot infer
the type, for the same reason?

[Stephan van Hulst]

Let's create an overview of all the type parameters:

<T1, A1, R1>                         R1                              Stream.collect           (Collector <? super T1, A1, R1>)
<T2, K1, A2, D1>                     Collector<T2, ?, Map<K1, D1>    Collectors.groupingBy    (Function  <? super T2, ? extends K1>, Collector<? super T2, A2, D1>);
<T3, U1, A3, R2>                     Collector<T3, ?, R2>            Collectors.mapping       (Function  <? super T3, ? extends U1>, Collector<? super U1, A3, R2>);
<T4>                                 Collector<T4, ?, Optional<T4>>  Collectors.minBy         (Comparator<? super T4>)
<T5 extends Comparable<? super T5>>  Comparator<T5>                  Comparator.naturalOrder  ()

Now we infer types from top to bottom by substituting type arguments into the requested return types. For brevity, we replace every occurrence of Map<Integer, Optional<Character>> with MAP:

<A1>      MAP                                                  ohMy.collect             (Collector <? super String, A1, MAP>)
<A2>      Collector <? super String, ?, MAP>                   Collectors.groupingBy    (Function  <? super String, ? extends Integer> ,  Collector<? super String, A2, Optional<Character>>);
<U1, A3>  Collector <? super String, ?, Optional<Character>>   Collectors.mapping       (Function  <? super String, ? extends U1>      ,  Collector<? super U1    , A3, Optional<Character>>);
<U1>      Collector <? super U1    , ?, Optional<? super U1>>  Collectors.minBy         (Comparator<? super U1>)
<U1>      Comparator<? super U1>                               Comparator.naturalOrder  ()

Now we infer types from bottom to top by substituting return type arguments into the method arguments:

      MAP                                                  ohMy.collect             (Collector <? super String, ?, MAP>)
      Collector <? super String, ?, MAP>                   Collectors.groupingBy    (Function  <? super String, ? extends Integer> ,  Collector<? super String, ?, Optional<Character>>);
<U1>  Collector <? super String, ?, Optional<Character>>   Collectors.mapping       (Function  <? super String, ? extends U1>      ,  Collector<? super U1    , ?, Optional<Character>>);
<U1>  Collector <? super U1    , ?, Optional<? super U1>>  Collectors.minBy         (Comparator<? super U1>)
<U1>  Comparator<? super U1>                               Comparator.naturalOrder  ()

As you can see, U1 can't be inferred. The solution is to explicitly specify the type in one of the three incomplete method calls.

Either of the following solutions should work:

Comparator.<Character>naturalOrder()

Collectors.<Character>minBy()

(String s) -> s.charAt(0)

[edit]

Sorry for the long lines, it's the only way I could format it with it still making sense.

[T Vergilio]

It seems that way, since casting the argument also works:

Collectors.minBy((Comparator<Character>)Comparator.naturalOrder())

[T Vergilio]

Hi Stephan,

Thanks for the insight. What I don't understand though is how it seems to work for certain people. Either the type can be inferred and it will always work, or it can't and it will never work.

Don't you agree?

[Piet Souris]

Good heavens!

But very educational. I know know that it is:

Comparator.<Character>naturalOrder()

No wonder all my attemps: Comparator<Character>.naturalOrder()
failed. Never too old to learn, I guess.

@T Vergilio
Indeed. Maybe Jeanne can explain how she managed.

@Stephan
Great job!

[Stephan van Hulst]

T Vergilio wrote:What I don't understand though is how it seems to work for certain people. Either the type can be inferred and it will always work, or it can't and it will never work.

I agree in part. Note that in my schema above, Collectors.minBy() could have inferred that U1 is Character, because Collectors.mapping() requested a Collector that produces an Optional<Character>. I think it was too complicated to implement at this time, but that doesn't mean it couldn't in the future.

What's weird is that it works for Jeanne, who isn't using a particularly new Java version.

Piet Souris wrote:No wonder all my attemps: Comparator<Character>.naturalOrder() failed. Never too old to learn, I guess.

That's why I like the C# way of explicitly providing type arguments after the identifier of whatever it is you're providing the types to. For a generic class: List<Character>, for a generic method: Comparator.naturalOrder<Character>().

[Jeanne Boyarsky]

I'm late to the party, but I agree it was a JDK "change of behavior." I had an older version of Java 8 in my path when I tried it on January 27th so that wasn't a valid test.

[Elaine Byrne]

I'd buy pie (or   ) for everyone, but I'm too tired after going through all the variants and clicking the +1 button on the posts    

[Ramesh Natesan]

Jeanne Boyarsky wrote:I'm late to the party, but I agree it was a JDK "change of behavior." I had an older version of Java 8 in my path when I tried it on January 27th so that wasn't a valid test.

I think this should be added to list of errata (https://www.selikoff.net/jpt/)?

[Jeanne Boyarsky]

Ramesh Natesan wrote:

Jeanne Boyarsky wrote:I'm late to the party, but I agree it was a JDK "change of behavior." I had an older version of Java 8 in my path when I tried it on January 27th so that wasn't a valid test.

I think this should be added to list of errata (https://www.selikoff.net/jpt/)?

This thread is about the OCP book. Do you see an example that is wrong in the Java Practice Tests book?