mjhjmtu

This is from the Stream interface from Oracles implementation of JDK 8:

public interface Stream<T> extends BaseStream<T, Stream<T>> 
 Stream<T> sorted();
 

and it is very easy to blow this in run-time and no warning will be generated in compile time, here is an example:

class Foo 
 public static void main(String args) 
 Arrays.asList(new Foo(), new Foo()).stream().sorted().forEach(f -> );
 

which will compile just fine but will throw an exception in runtime:

Exception in thread "main" java.lang.ClassCastException: Foo cannot be cast to java.lang.Comparable

What can be the reason that sorted method was not defined where compiler could actually catch such problems? Maybe I am wrong but isn 't it this simple:

interface Stream<T> 
 <C extends Comparable<T>> void sorted(C c);

?

Obviously the guys implementing this (who are light years ahead of me as far as programming and engineering is considered) must have a very good reason that I am unable to see, but what is that reason?

How would you implement that? sorted is a intermediate operation (can be called anywhere between other intermediate operations), meaning you can start with a stream that is not Comparable, but call sorted on one that is Comparable:

Arrays.asList(new Foo(), new Foo())
 .stream()
 .map(Foo::getName) // name is a String for example
 .sorted()
 .forEach(f -> );

The thing that you are proposing takes an argument as input, but Stream::sorted does not, so you can't do that. The overload version accepts a Comparator - meaning you can sort something by a property, but still return Stream<T>. I think that this is quite easy to understand if you would try to write your minimal skeleton of a Stream interface/implementation.

The documentation for Stream#sorted explains it perfectly:

Returns a stream consisting of the elements of this stream, sorted according to natural order. If the elements of this stream are not Comparable, a java.lang.ClassCastException may be thrown when the terminal operation is executed.

You're using the overloaded method that accepts no arguments (not the one that accepts a Comparator), and Foo does not implement Comparable.

If you're asking why the method doesn't throw a compiler error if the contents of the Stream do not implement Comparable, it would be because T is not forced to extend Comparable, and T cannot be changed without a call to Stream#map; it seems to only be a convenience method so no explicit Comparator needs to be provided when the elements already implement Comparable.

For it to be type-safe, T would have to extend Comparable, but that would be ridiculous, as it would prevent a stream from containing any objects that aren't Comparable.