Java Stream.collect en Kotlin : guide complet avec exemples

Comment arrêter d'écrire Stream.collect en Kotlin et commencer à vivre

Avez-vous déjà migré de Java vers Kotlin en vous sentant comme un poisson hors de l'eau ? Surtout en ce qui concerne les streams. En Java 8, nous étions habitués aux chaînes .stream().filter().map().collect(). Et en Kotlin — boum ! — il n'y a pas de Stream.collect sous sa forme habituelle. Mais ne paniquez pas. En réalité, la bibliothèque standard de Kotlin contient tout ce qu'il faut, mais de manière plus pratique, plus concise et sans bruit inutile.

Dans cet article, nous allons voir quels sont les équivalents de Java 8 Stream.collect disponibles en Kotlin, et les illustrer avec des exemples concrets. Si vous cherchez la réponse à la question "Quels sont les équivalents de Java 8 Stream.collect dans la bibliothèque standard Kotlin ?" — vous êtes au bon endroit. Nous passerons en revue les opérations les plus courantes : de la simple collecte dans une liste au regroupement complexe et à la concaténation de chaînes.

Prêts ? C'est parti !

1. Le cas le plus simple : toList() et toSet()

En Java, pour collecter le résultat d'un stream dans une liste, vous écrivez :

List<String> result = list.stream()    .filter(s -> s.length() > 3)    .collect(Collectors.toList());

En Kotlin, cela se transforme en une seule ligne sans collect :

val result = list.filter { it.length > 3 }

Oui, vous avez bien entendu. filter en Kotlin renvoie déjà une liste. Mais si vous devez spécifier explicitement le type de collection, utilisez toList(), toSet() ou toMutableList() :

val numbers = listOf(1, 2, 3, 4, 5, 5)val uniqueNumbers: Set<Int> = numbers.toSet()// Résultat : [1, 2, 3, 4, 5]

Conclusion : en Kotlin, la plupart des opérations sur les collections (filter, map, flatMap) renvoient directement une liste. collect(Collectors.toList()) ne vous est plus nécessaire.

2. Regroupement : groupingBy au lieu de Collectors.groupingBy

Le regroupement est l'une des tâches les plus courantes. En Java, cela ressemble à ceci :

Map<Integer, List<String>> byLength = list.stream()    .collect(Collectors.groupingBy(String::length));

En Kotlin, il existe une fonction élégante groupBy :

val words = listOf("chat", "code", "chaudron", "chaton")val byLength = words.groupBy { it.length }// Résultat : {3=[chat, code], 5=[chaudron], 4=[chaton]}

Mais il y a un détail : groupBy renvoie directement un Map<K, List<V>>. Et si vous avez besoin de quelque chose de plus complexe, comme compter le nombre d'éléments dans chaque groupe ? En Java, vous utiliseriez Collectors.counting() :

Map<Integer, Long> countByLength = list.stream()    .collect(Collectors.groupingBy(String::length, Collectors.counting()));

En Kotlin, pour cela, il y a groupingBy + eachCount :

val countByLength = words.groupingBy { it.length }.eachCount()// Résultat : {3=2, 5=1, 4=1}

Et si vous voulez collecter non pas une liste, mais par exemple un ensemble ? Utilisez groupBy avec une transformation :

val byLengthSet = words.groupBy(keySelector = { it.length }, valueTransform = { it.uppercase() })// Résultat : {3=[CHAT, CODE], 5=[CHAUDRON], 4=[CHATON]}

Conseil : si vous avez besoin de quelque chose entre groupBy et groupingBy, utilisez groupingBy — il est paresseux et permet d'appliquer différentes agrégations (eachCount, fold, reduce).

3. Concaténation de chaînes : joinToString() au lieu de Collectors.joining()

En Java, la concaténation de chaînes avec un séparateur :

String joined = list.stream()    .collect(Collectors.joining(", "));

En Kotlin, c'est encore plus simple :

val words = listOf("Kotlin", "Java", "Python")val joined = words.joinToString(",