Programmation par flots

En informatique, le terme flot (stream) désigne généralement une séquence de valeurs auxquelles on accède l'une après l'autre, de la première à la dernière. En Java, cette notion apparaît dans deux contextes :

1. les entrées/sorties, puisque les données lues ou écrites par le programme sont modélisées par des flots d'octets ou des caractères,
2. ce que l'on nomme parfois la programmation par flots, sujet de cette leçon.

La programmation par flots (stream programming) consiste à exprimer un calcul sur des données au moyen d'un enchaînement d'opérations simples appliquées au flot de ces données.

Comme nous le verrons, les lambdas permettent d'exprimer de manière concise les opérations à effectuer sur les données du flot. Pour cette raison, plusieurs classes et méthodes ont été introduites en Java 8 — en même temps que les lambdas — pour faciliter la programmation par flots.

Pour illustrer l'intérêt de la programmation par flots, admettons que l'on désire convertir un fichier contenant des températures en degrés Fahrenheit en un fichier contenant ces mêmes températures en degrés Celsius, en ignorant les lignes vides. Par exemple, si le fichier d'entrée contient les trois lignes suivantes (la seconde étant vide) :

1: 0
2: 
3: 100

le fichier de sortie doit contenir les deux lignes :

1: -17.777
2: 37.777

Cette conversion peut s'exprimer par la transformation de flots suivante :

1. obtenir le flot des lignes du fichier d'entrée,
2. filtrer ce flot pour ne garder que les lignes non vides,
3. convertir le flot de lignes — des chaînes de caractères — en un flot de températures en °F — des nombres réels,
4. convertir le flot des températures en °F en flot des températures en °C, au moyen de la formule de conversion [°C = (°F − 32) × 5/9],
5. écrire chaque valeur du flot dans le fichier de sortie, une par ligne.

Cette transformation de flot peut également se visualiser facilement, comme l'illustre la figure 1.

En utilisant les classes et méthodes que nous allons examiner, cette conversion peut se traduire très directement en un programme Java :

try (BufferedReader r =
       new BufferedReader(new FileReader("f.txt"));
     PrintWriter w =
       new PrintWriter(new FileWriter("c.txt"))) {
  r.lines()                          // lignes
    .filter(l -> !l.isEmpty())       // lignes non vides
    .map(Double::parseDouble)        // températures °F
    .map(f -> (f - 32d) * (5d / 9d)) // températures °C
    .forEachOrdered(w::println);
}

Le paquetage java.util.stream — nouveauté de la version 8 de Java — définit plusieurs classes et interfaces permettant de faire de la programmation par flots.

L'interface Stream de ce paquetage représente un flot de valeurs d'un type donné. Elle est naturellement générique, son paramètre de type représentant le type des valeurs du flot :

public interface Stream<T> {
  // … méthodes
}

Par exemple, le flot des lignes d'un fichier a le type Stream<String>, celui des températures — en °F ou °C — le type Stream<Double>, etc.

Pour des raisons de performances, il existe également des interfaces représentant des flots de trois types de nombres, à savoir :

1. DoubleStream pour les flots de nombres à virgule flottante double,
2. LongStream pour les flots d'entiers long, et
3. IntStream pour les flots d'entiers int.

Ainsi, un flot d'entiers int peut être représenté de deux manières :

1. par un flot général de type Stream<Integer>, dans lequel chaque entier est représenté par un objet de type Integer,
2. par un flot spécialisé de type IntStream, dans lequel chaque entier est représenté par une valeur de type int.

La seconde représentation est plus efficace car elle évite la création d'objets, et doit autant que possible être préférée lorsque les performances sont importantes.

Les méthodes qui travaillent sur les flots — celles de l'interface Stream ou autres — appartiennent toutes à exactement une des trois catégories suivantes :

1. les méthodes sources, qui produisent un flot de valeurs à partir d'une source qui peut p.ex. être une collection, un fichier, etc.
2. les méthodes intermédiaires, qui transforment les valeurs du flot et produisent un nouveau flot,
3. les méthodes terminales, qui consomment les valeurs du flot, p.ex. en les écrivant dans un fichier, en les réduisant à une valeur unique, etc.

Ces trois types de méthodes sont utilisés pour construire ce que l'on nomme parfois des pipelines. Un pipeline est formé de :

• une méthode source, qui produit un flot de valeurs,
• zero ou plusieurs méthodes intermédiaires, qui transforment les valeurs,
• une méthode terminale, qui consomme les valeurs.

La transformation de °F en °C présentée précédemment est un tel pipeline, dans lequel la méthode lines est la méthode source, les méthodes filter et map sont les méthodes intermédiaires, et la méthode forEachOrdered la méthode terminale.

Il est important de savoir que les flots ne sont pas immuables, dans le sens où lorsque les éléments d'un flot sont consommés par une méthode terminale, ils disparaissent et le flot est ensuite vide. En cela, les flots sont similaires aux itérateurs, qui sont également modifiés lors de leur parcours.

Les principales méthodes sources, intermédiaires et terminales fournies par la bibliothèque Java sont présentées ci-dessous. Cette liste n'est toutefois pas exhaustive, et les types ont souvent été simplifiés pour des raisons pédagogiques.

La classe Collectors du paquetage java.util.stream, non instanciable, fournit des méthodes statiques permettant d'obtenir des collecteurs à passer à la méthode collect des flots.

Dans ce qui suit, le type de retour des différentes méthodes n'est jamais montré car il a tendance à être compliqué et sa compréhension n'est pas nécessaire à l'utilisation de ces collecteurs. En effet, ceux-ci sont toujours passés directement à la méthode collect de Stream. L'exemple suivant, qui trie une liste par l'intermédiaire d'un flot afin de ne pas modifier la liste originale, l'illustre :

List<String> l = List.of("un", "deux", "trois");
List<String> sortedL = l.stream()
  .sorted()
  .collect(Collectors.toList());

Seul un sous-ensemble, jugé particulièrement utile, des collecteurs existants est présenté ci-après.

• la documentation de l'API Java, en particulier les classes et interfaces suivantes :
  • le paquetage java.util.stream, en particulier sa description,
  • l'interface java.util.stream.Stream et ses spécialisations :
    • l'interface java.util.stream.IntStream,
    • l'interface java.util.stream.LongStream,
    • l'interface java.util.stream.DoubleStream,
  • la classe java.util.stream.Collectors.