等效Java和Kotlin Stream代码之间的意外类型差异

Question

EDIT March 1 2016: Fair warning: this question was asked about Kotlin before 1.0.0. Things are different since Kotlin 1.0.0. See @Jayson Minard's writing below for a Kotlin 1.0.0 answer.

In Java 8 code that uses Stream, I write things like

public static void main(String... args) {
    Stream<Integer> integerStream = Stream.of(1,2,3);
    List<Integer> integerList = integerStream.collect(Collectors.toList());
}

But in similar code written in Kotlin, I get unexpected results.

public fun main(args: Array<String>) {
    val integerStream : Stream<Int> = Stream.of(1, 2, 3)

    // this is what I expect to write, like the Java 8 code, but is a compilation error: 
    // "required: java.util.List<in kotlin.Int> found: kotlin.MutableList<in kotlin.Int!"
    // val list : java.util.List<in Int> = integerStream.collect(Collectors.toList()) 

    // I must instead write this
    val list : MutableList<in Int> = integerStream.collect(Collectors.toList())
}

Why would the return value of the Stream#collect expression be of a different list type in the Kotlin code than in the Java code? (I'm guessing it is because of some Java Collections-specific magic in Kotlin)

Answer 1

I think it is because List in Java are mutable be default, where as in Kotlin they are immutable. In the code you are using a Java specific utility, Collectors.toList which returns a Java List , which to Kotlin translates as a MutableList , so in effect you are writing the same code, just the type names are different.

Answer 2

You can do this in Kotlin 1.0:

val integerStream : Stream<Int> = Stream.of(1, 2, 3)
val list : List<Int> = integerStream.collect(Collectors.toList<Int>())

or

val integerStream : Stream<Int> = Stream.of(1, 2, 3)
val list : MutableList<Int> = integerStream.collect(Collectors.toList<Int>())

or not care, and let inference decide:

val integerStream = Stream.of(1, 2, 3)
val list = integerStream.collect(Collectors.toList<Int>())

NOTE: I changed your toList() call into toList<Int>() to work around the issue mentioned in https://stackoverflow.com/a/35722167/3679676

You can also create an extension function:

fun <T: Any> Stream<T>.toList(): List<T> = this.collect(Collectors.toList<T>())

And then use it for any Stream<T> to List<T> conversion:

val integerStream = Stream.of(1, 2, 3)
val list = integerStream.toList()

val stringStream = Stream.of("a", "b", "c")
val stringList = stringStream.toList()

And this last example is already returning the read only interface of List instead of MutableList . For the difference between these and other mapped interfaces in Kotlin, see the docs for Java Interop, mapped types .

Lastly, one other variant is to convert to a Sequence and stay lazy, since it is the Kotlin equivalent of a Stream .

fun <T: Any> Stream<T>.asSequence(): Sequence<T> = this.iterator().asSequence()

Or Stream.iterator() is similar, but not the same.