¿Qué equivalentes Java 8 Stream.collect están disponibles en la biblioteca estándar de Kotlin?

collections java-8

Question

En Java 8, hay Stream.collect que permite agregaciones en colecciones. En Kotlin, esto no existe de la misma manera, excepto tal vez como una colección de funciones de extensión en stdlib. Pero no está claro cuáles son las equivalencias para diferentes casos de uso.

Por ejemplo, en la parte superior de JavaDoc for Collectors hay ejemplos escritos para Java 8, y al portarlos a Kolin no puede usar las clases de Java 8 cuando está en una versión JDK diferente, por lo que es probable que se escriban de manera diferente.

En términos de recursos en línea que muestran ejemplos de colecciones de Kotlin, generalmente son triviales y realmente no se comparan con los mismos casos de uso. ¿Cuáles son buenos ejemplos que realmente coinciden con los casos documentados para Java 8 Stream.collect ? La lista hay:

• Acumula nombres en una lista
• Acumula nombres en un TreeSet
• Convierta elementos en cadenas y concatenelos, separados por comas
• Calcular la suma de los salarios del empleado
• Agrupar empleados por departamento
• Calcular la suma de salarios por departamento
• Particionar a los estudiantes para aprobar y reprobar

Con detalles en el JavaDoc vinculado anteriormente.

Nota: esta pregunta está escrita y respondida intencionalmente por el autor ( Preguntas con respuesta propia ), de modo que las respuestas idiomáticas a los temas de Kotlin más frecuentes están presentes en SO. También para aclarar algunas respuestas realmente antiguas escritas para alfas de Kotlin que no son precisas para el Kotlin actual.

Answer 1

Más sobre la pereza

Tomemos la solución de ejemplo para "Calcular la suma de salarios por departamento" dada por Jayson:

val totalByDept = employees.groupBy { it.dept }.mapValues { it.value.sumBy { it.salary }}

Para hacer esto perezoso (es decir, evitar crear un mapa intermedio en el paso groupBy ), no es posible usar asSequence() . En su lugar, debemos usar la operación groupingBy y fold :

val totalByDept = employees.groupingBy { it.dept }.fold(0) { acc, e -> acc + e.salary }

Para algunas personas, esto puede incluso ser más legible, ya que no se trata de entradas de mapas: la parte it.value de la solución también me resultó confusa al principio.

Dado que este es un caso común y preferiríamos no escribir el fold cada vez, puede ser mejor simplemente proporcionar una función genérica sumBy en Grouping :

public inline fun <T, K> Grouping<T, K>.sumBy(
selector: (T) -> Int
): Map<K, Int> =
fold(0) { acc, element -> acc + selector(element) }

para que podamos simplemente escribir:

val totalByDept = employees.groupingBy { it.dept }.sumBy { it.salary }

Answer 2

Hay algunos casos en los que es difícil evitar llamar a collect(Collectors.toList()) o similar. En esos casos, puede cambiar más rápidamente a un equivalente de Kotlin utilizando funciones de extensión como:

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

Luego puede simplemente stream.toList() o stream.asSequence() para volver a la API de Kotlin. Un caso como Files.list(path) obliga a ingresar a Stream cuando no lo desee, y estas extensiones pueden ayudarlo a volver a las colecciones estándar y la API de Kotlin.

Answer 3

Hay funciones en Kotlin stdlib para promedio, conteo, distinción, filtrado, búsqueda, agrupación, unión, mapeo, mínimo, máximo, partición, división, clasificación, suma, a / desde matrices, a / desde listas, a / desde mapas , unión, co-iteración, todos los paradigmas funcionales y más. Por lo tanto, puede usarlos para crear pequeños 1-liners y no hay necesidad de usar la sintaxis más complicada de Java 8.

Creo que lo único que falta en la clase incorporada de Java 8 Collectors es el resumen (pero en otra respuesta a esta pregunta es una solución simple) .

Una cosa que falta en ambos es la agrupación por conteo, que se ve en otra respuesta de desbordamiento de pila y también tiene una respuesta simple. Otro caso interesante es este también de : forma idiomática de secuenciar derramada en tres listas usando Kotlin . Y si desea crear algo como Stream.collect para otro propósito, vea Stream.collect personalizado en Kotlin

EDITAR 11.08.2017: Se agregaron operaciones de recolección fragmentadas / en ventanas en kotlin 1.2 M2, consulte https://blog.jetbrains.com/kotlin/2017/08/kotlin-1-2-m2-is-out/

Siempre es bueno explorar la Referencia de API para kotlin.collections en su conjunto antes de crear nuevas funciones que ya puedan existir allí.

Aquí hay algunas conversiones de Java 8 Stream.collect ejemplos al equivalente en Kotlin:

Acumula nombres en una lista

// Java:
List<String> list = people.stream().map(Person::getName).collect(Collectors.toList());

// Kotlin:
val list = people.map { it.name } // toList() not needed

Convierta elementos en cadenas y concatenelos, separados por comas

// Java:
String joined = things.stream()
.map(Object::toString)
.collect(Collectors.joining(", "));

// Kotlin:
val joined = things.joinToString(", ")

Calcular la suma de los salarios del empleado

// Java:
int total = employees.stream()
.collect(Collectors.summingInt(Employee::getSalary)));

// Kotlin:
val total = employees.sumBy { it.salary }

Agrupar empleados por departamento

// Java:
Map<Department, List<Employee>> byDept
= employees.stream()
.collect(Collectors.groupingBy(Employee::getDepartment));

// Kotlin:
val byDept = employees.groupBy { it.department }

Calcular la suma de salarios por departamento

// Java:
Map<Department, Integer> totalByDept
= employees.stream()
.collect(Collectors.groupingBy(Employee::getDepartment,
Collectors.summingInt(Employee::getSalary)));

// Kotlin:
val totalByDept = employees.groupBy { it.dept }.mapValues { it.value.sumBy { it.salary }}

Particionar a los estudiantes para aprobar y reprobar

// Java:
Map<Boolean, List<Student>> passingFailing =
students.stream()
.collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

// Kotlin:
val passingFailing = students.partition { it.grade >= PASS_THRESHOLD }

Nombres de miembros masculinos

// Java:
List<String> namesOfMaleMembers = roster
.stream()
.filter(p -> p.getGender() == Person.Sex.MALE)
.map(p -> p.getName())
.collect(Collectors.toList());

// Kotlin:
val namesOfMaleMembers = roster.filter { it.gender == Person.Sex.MALE }.map { it.name }

Agrupe los nombres de los miembros en la lista por género

// Java:
Map<Person.Sex, List<String>> namesByGender =
roster.stream().collect(
Collectors.groupingBy(
Person::getGender,
Collectors.mapping(
Person::getName,
Collectors.toList())));

// Kotlin:
val namesByGender = roster.groupBy { it.gender }.mapValues { it.value.map { it.name } } 

Filtrar una lista a otra lista

// Java:
List<String> filtered = items.stream()
.filter( item -> item.startsWith("o") )
.collect(Collectors.toList());

// Kotlin:
val filtered = items.filter { it.startsWith(''o'') } 

Encontrar la cadena más corta de una lista

// Java:
String shortest = items.stream()
.min(Comparator.comparing(item -> item.length()))
.get();

// Kotlin:
val shortest = items.minBy { it.length }

Contar elementos en una lista después de aplicar el filtro

// Java:
long count = items.stream().filter( item -> item.startsWith("t")).count();

// Kotlin:
val count = items.filter { it.startsWith(''t'') }.size
// but better to not filter, but count with a predicate
val count = items.count { it.startsWith(''t'') }

y así sucesivamente ... En todos los casos, no fue necesario plegar, reducir u otra funcionalidad especial para imitar Stream.collect . Si tiene más casos de uso, agréguelos en los comentarios y ¡podemos ver!

Sobre la pereza

Si desea procesar de forma diferida una cadena, puede convertirla en una Sequence utilizando asSequence() antes de la cadena. Al final de la cadena de funciones, generalmente terminas con una Sequence también. Luego puede usar toList() , toSet() , toMap() o alguna otra función para materializar la Sequence al final.

// switch to and from lazy
val someList = items.asSequence().filter { ... }.take(10).map { ... }.toList()
// switch to lazy, but sorted() brings us out again at the end
val someList = items.asSequence().filter { ... }.take(10).map { ... }.sorted()

¿Por qué no hay tipos?

Notará que los ejemplos de Kotlin no especifican los tipos. Esto se debe a que Kotlin tiene inferencia de tipo completa y es completamente segura en el momento de la compilación. Más que Java porque también tiene tipos anulables y puede ayudar a prevenir el temido NPE. Entonces esto en Kotlin:

val someList = people.filter { it.age <= 30 }.map { it.name }

es lo mismo que:

val someList: List<String> = people.filter { it.age <= 30 }.map { it.name }

Debido a que Kotlin sabe qué es la people , y que people.age es Int por lo tanto, la expresión de filtro solo permite la comparación con un Int , y que people.name es una String por lo tanto, el paso del map produce una List<String> (solo List de String ).

Ahora, si las people posiblemente fueran null , ¿como en una List<People>? entonces:

val someList = people?.filter { it.age <= 30 }?.map { it.name }

Devuelve una List<String>? eso necesitaría ser anulado ( o usar uno de los otros operadores de Kotlin para valores anulables, vea esta forma idiomática de Kotlin para tratar con valores anulables y también una forma idiomática de manejar la lista nula o vacía en Kotlin )

Ver también:

• Referencia de API para funciones de extensión para Iterable
• Referencia de API para funciones de extensión para Array
• Referencia de API para funciones de extensión para List
• Referencia de API para funciones de extensión a Map

Answer 4

Para ejemplos adicionales, aquí están todos los ejemplos de Java 8 Stream Tutorial convertidos a Kotlin. El título de cada ejemplo se deriva del artículo fuente:

Cómo funcionan las transmisiones

// Java:
List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");
myList.stream()
.filter(s -> s.startsWith("c"))
.map(String::toUpperCase)
.sorted()
.forEach(System.out::println);
// C1
// C2

// Kotlin:
val list = listOf("a1", "a2", "b1", "c2", "c1")
list.filter { it.startsWith(''c'') }.map (String::toUpperCase).sorted()
.forEach (::println)

Diferentes tipos de corrientes # 1

// Java:
Arrays.asList("a1", "a2", "a3")
.stream()
.findFirst()
.ifPresent(System.out::println); 

// Kotlin:
listOf("a1", "a2", "a3").firstOrNull()?.apply(::println)

o cree una función de extensión en String llamada ifPresent:

// Kotlin:
inline fun String?.ifPresent(thenDo: (String)->Unit) = this?.apply { thenDo(this) }
// now use the new extension function:
listOf("a1", "a2", "a3").firstOrNull().ifPresent(::println)

Ver también: función apply()

Ver también: Funciones de extensión

Ver también: Operador Safe Call y, en general, nulabilidad: en Kotlin, ¿cuál es la forma idiomática de tratar con valores anulables, hacer referencia o convertirlos?

Diferentes tipos de corrientes # 2

// Java:
Stream.of("a1", "a2", "a3")
.findFirst()
.ifPresent(System.out::println); 

// Kotlin:
sequenceOf("a1", "a2", "a3").firstOrNull()?.apply(::println)

Diferentes tipos de corrientes # 3

// Java:
IntStream.range(1, 4).forEach(System.out::println);

// Kotlin: (inclusive range)
(1..3).forEach(::println)

Diferentes tipos de corrientes # 4

// Java:
Arrays.stream(new int[] {1, 2, 3})
.map(n -> 2 * n + 1)
.average()
.ifPresent(System.out::println); // 5.0 

// Kotlin:
arrayOf(1,2,3).map { 2 * it + 1}.average().apply(::println)

Diferentes tipos de corrientes # 5

// Java:
Stream.of("a1", "a2", "a3")
.map(s -> s.substring(1))
.mapToInt(Integer::parseInt)
.max()
.ifPresent(System.out::println); // 3

// Kotlin:
sequenceOf("a1", "a2", "a3")
.map { it.substring(1) }
.map(String::toInt)
.max().apply(::println)

Diferentes tipos de corrientes # 6

// Java:
IntStream.range(1, 4)
.mapToObj(i -> "a" + i)
.forEach(System.out::println);
// a1
// a2
// a3 

// Kotlin: (inclusive range)
(1..3).map { "a$it" }.forEach(::println)

Diferentes tipos de corrientes # 7

// Java:
Stream.of(1.0, 2.0, 3.0)
.mapToInt(Double::intValue)
.mapToObj(i -> "a" + i)
.forEach(System.out::println);
// a1
// a2
// a3

// Kotlin:
sequenceOf(1.0, 2.0, 3.0).map(Double::toInt).map { "a$it" }.forEach(::println)

Por qué es importante el pedido

Esta sección de Java 8 Stream Tutorial es la misma para Kotlin y Java.

Reutilizando Streams

En Kotlin, depende del tipo de colección si se puede consumir más de una vez. Una Sequence genera un nuevo iterador cada vez y, a menos que afirme "usar solo una vez", puede reiniciarse al inicio cada vez que se actúa. Por lo tanto, aunque lo siguiente falla en la secuencia Java 8, pero funciona en Kotlin:

// Java:
Stream<String> stream =
Stream.of("d2", "a2", "b1", "b3", "c").filter(s -> s.startsWith("b"));
stream.anyMatch(s -> true); // ok
stream.noneMatch(s -> true); // exception

// Kotlin:
val stream = listOf("d2", "a2", "b1", "b3", "c").asSequence().filter { it.startsWith(''b'' ) }
stream.forEach(::println) // b1, b2
println("Any B ${stream.any { it.startsWith(''b'') }}") // Any B true
println("Any C ${stream.any { it.startsWith(''c'') }}") // Any C false
stream.forEach(::println) // b1, b2

Y en Java para obtener el mismo comportamiento:

// Java:
Supplier<Stream<String>> streamSupplier =
() -> Stream.of("d2", "a2", "b1", "b3", "c")
.filter(s -> s.startsWith("a"));
streamSupplier.get().anyMatch(s -> true); // ok
streamSupplier.get().noneMatch(s -> true); // ok

Por lo tanto, en Kotlin, el proveedor de los datos decide si se puede restablecer y proporcionar un nuevo iterador o no. Pero si desea restringir intencionalmente una Sequence a una iteración única, puede usar la función constrainOnce() para la Sequence siguiente manera:

val stream = listOf("d2", "a2", "b1", "b3", "c").asSequence().filter { it.startsWith(''b'' ) }
.constrainOnce()
stream.forEach(::println) // b1, b2
stream.forEach(::println) // Error:java.lang.IllegalStateException: This sequence can be consumed only once. 

Operaciones avanzadas

Recopile el ejemplo 5 (sí, omití los que ya aparecen en la otra respuesta)

// Java:
String phrase = persons
.stream()
.filter(p -> p.age >= 18)
.map(p -> p.name)
.collect(Collectors.joining(" and ", "In Germany ", " are of legal age."));
System.out.println(phrase);
// In Germany Max and Peter and Pamela are of legal age. 

// Kotlin:
val phrase = persons.filter { it.age >= 18 }.map { it.name }
.joinToString(" and ", "In Germany ", " are of legal age.")
println(phrase)
// In Germany Max and Peter and Pamela are of legal age.

Y como nota al margen, en Kotlin podemos crear clases de datos simples e instanciar los datos de prueba de la siguiente manera:

// Kotlin:
// data class has equals, hashcode, toString, and copy methods automagically
data class Person(val name: String, val age: Int)
val persons = listOf(Person("Tod", 5), Person("Max", 33),
Person("Frank", 13), Person("Peter", 80),
Person("Pamela", 18))

Recoge el ejemplo # 6

// Java:
Map<Integer, String> map = persons
.stream()
.collect(Collectors.toMap(
p -> p.age,
p -> p.name,
(name1, name2) -> name1 + ";" + name2));
System.out.println(map);
// {18=Max, 23=Peter;Pamela, 12=David} 

Ok, un caso más interesante aquí para Kotlin. Primero, las respuestas incorrectas para explorar las variaciones de crear un Map partir de una colección / secuencia:

// Kotlin:
val map1 = persons.map { it.age to it.name }.toMap()
println(map1)
// output: {18=Max, 23=Pamela, 12=David}
// Result: duplicates overridden, no exception similar to Java 8
val map2 = persons.toMap({ it.age }, { it.name })
println(map2)
// output: {18=Max, 23=Pamela, 12=David}
// Result: same as above, more verbose, duplicates overridden
val map3 = persons.toMapBy { it.age }
println(map3)
// output: {18=Person(name=Max, age=18), 23=Person(name=Pamela, age=23), 12=Person(name=David, age=12)}
// Result: duplicates overridden again
val map4 = persons.groupBy { it.age }
println(map4)
// output: {18=[Person(name=Max, age=18)], 23=[Person(name=Peter, age=23), Person(name=Pamela, age=23)], 12=[Person(name=David, age=12)]}
// Result: closer, but now have a Map<Int, List<Person>> instead of Map<Int, String>
val map5 = persons.groupBy { it.age }.mapValues { it.value.map { it.name } }
println(map5)
// output: {18=[Max], 23=[Peter, Pamela], 12=[David]}
// Result: closer, but now have a Map<Int, List<String>> instead of Map<Int, String>

Y ahora para la respuesta correcta:

// Kotlin:
val map6 = persons.groupBy { it.age }.mapValues { it.value.joinToString(";") { it.name } }
println(map6)
// output: {18=Max, 23=Peter;Pamela, 12=David}
// Result: YAY!!

Solo necesitábamos unir los valores coincidentes para colapsar las listas y proporcionar un transformador a jointToString para pasar de la instancia de Person al Person.name .

Recoge el ejemplo # 7

Ok, esto se puede hacer fácilmente sin un Collector personalizado, así que resolvamos el método de Kotlin, luego inventemos un nuevo ejemplo que muestre cómo hacer un proceso similar para Collector.summarizingInt que no existe de forma nativa en Kotlin.

// Java:
Collector<Person, StringJoiner, String> personNameCollector =
Collector.of(
() -> new StringJoiner(" | "), // supplier
(j, p) -> j.add(p.name.toUpperCase()), // accumulator
(j1, j2) -> j1.merge(j2), // combiner
StringJoiner::toString); // finisher
String names = persons
.stream()
.collect(personNameCollector);
System.out.println(names); // MAX | PETER | PAMELA | DAVID 

// Kotlin:
val names = persons.map { it.name.toUpperCase() }.joinToString(" | ")

¡No es mi culpa que hayan elegido un ejemplo trivial! Ok, aquí hay un nuevo método summaryInt para Kotlin y una muestra coincidente:

Resumen de ejemplo

// Java:
IntSummaryStatistics ageSummary =
persons.stream()
.collect(Collectors.summarizingInt(p -> p.age));
System.out.println(ageSummary);
// IntSummaryStatistics{count=4, sum=76, min=12, average=19.000000, max=23} 

// Kotlin:
// something to hold the stats...
data class SummaryStatisticsInt(var count: Int = 0,
var sum: Int = 0,
var min: Int = Int.MAX_VALUE,
var max: Int = Int.MIN_VALUE,
var avg: Double = 0.0) {
fun accumulate(newInt: Int): SummaryStatisticsInt {
count++
sum += newInt
min = min.coerceAtMost(newInt)
max = max.coerceAtLeast(newInt)
avg = sum.toDouble() / count
return this
}
}
// Now manually doing a fold, since Stream.collect is really just a fold
val stats = persons.fold(SummaryStatisticsInt()) { stats, person -> stats.accumulate(person.age) }
println(stats)
// output: SummaryStatisticsInt(count=4, sum=76, min=12, max=23, avg=19.0)

Pero es mejor crear una función de extensión, 2 para que coincida con los estilos en Kotlin stdlib:

// Kotlin:
inline fun Collection<Int>.summarizingInt(): SummaryStatisticsInt
= this.fold(SummaryStatisticsInt()) { stats, num -> stats.accumulate(num) }
inline fun <T: Any> Collection<T>.summarizingInt(transform: (T)->Int): SummaryStatisticsInt =
this.fold(SummaryStatisticsInt()) { stats, item -> stats.accumulate(transform(item)) }

Ahora tiene dos formas de utilizar las nuevas funciones de summarizingInt :

val stats2 = persons.map { it.age }.summarizingInt()
// or
val stats3 = persons.summarizingInt { it.age }

Y todos estos producen los mismos resultados. También podemos crear esta extensión para trabajar en Sequence y para los tipos primitivos apropiados.

Por diversión, compare el código JDK de Java con el código personalizado de Kotlin requerido para implementar este resumen.