Comment apprendre l’API Java Stream [+5 Resources]

par
Tweetez
Partagez
Enregistrer
Partagez
Partagez
0 Partages

Un flux en Java est une séquence d’éléments sur lesquels des opérations séquentielles ou parallèles peuvent être effectuées.

Il peut y avoir un nombre « n » d’opérations intermédiaires et, enfin, une opération terminale, après quoi le résultat est renvoyé.

Qu’est-ce qu’un flux ?

Les flux peuvent être gérés par l’API Stream, qui a été introduite dans Java 8.

Imaginez Stream comme un pipeline de fabrication dans lequel certaines marchandises doivent être fabriquées, triées, puis emballées pour l’expédition. En Java, ces marchandises sont des objets ou des collections d’objets, les opérations sont la fabrication, le tri et l’emballage, et le pipeline est le flux.

Les composants d’un flux sont :

  • Une entrée initiale
  • Opérations intermédiaires
  • Exploitation des bornes
  • Résultat final

Explorons quelques fonctionnalités d’un flux en Java :

  • Stream n’est pas une structure de données en mémoire ; il s’agit plutôt d’une séquence de tableaux, d’objets ou de collections d’objets qui sont exploités par certaines méthodes.
  • Les flux sont de nature déclarative, c’est-à-dire que vous spécifiez quoi faire mais pas comment le faire.
  • Ils ne peuvent être consommés qu’une seule fois car ils ne sont stockés nulle part.
  • Stream ne modifie pas la structure de données d’origine ; il n’en tire qu’une nouvelle structure.
  • Il renvoie le résultat final dérivé de la méthode finale dans le pipeline.

API de flux vs traitement des collections

Une collection est une structure de données en mémoire qui stocke et traite les données. Les collections fournissent des structures de données telles que Set, Map, List, etc., pour stocker des données. D’autre part, un flux est un moyen de transférer efficacement des données après les avoir traitées via un pipeline.

Voici un exemple d’une collection ArrayList : –

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(0, 3);
        System.out.println(list);
    }
}

Output: 
[3]

Comme vous pouvez le voir dans l’exemple ci-dessus, vous pouvez créer une collection ArrayList, y stocker des données, puis opérer sur ces données en utilisant différentes méthodes.

À l’aide d’un flux, vous pouvez opérer sur une structure de données existante et renvoyer une nouvelle valeur modifiée. Vous trouverez ci-dessous un exemple de création d’une collection ArrayList et de filtrage à l’aide d’un flux.

import java.util.ArrayList;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();

        for (int i = 0; i < 20; i++) {
            list.add(i+1);
        }

        System.out.println(list);

        Stream<Integer> filtered = list.stream().filter(num -> num > 10);
        filtered.forEach(num -> System.out.println(num + " "));
    }
}

#Output

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
11 
12 
13 
14 
15 
16 
17 
18 
19 
20

Dans l’exemple ci-dessus, un flux est créé à l’aide de la liste existante et la liste est itérée pour filtrer les valeurs supérieures à 10. Notez que le flux ne stocke rien, la liste est juste itérée et le résultat est imprimé. Si vous essayez d’imprimer le flux, vous obtiendrez une référence au flux au lieu de valeurs.

Travailler sur l’API Java Stream

L’API Java Stream prend une collection source d’éléments ou une séquence d’éléments, puis effectue des opérations sur eux pour dériver un résultat final. Un flux n’est qu’un pipeline à travers lequel une séquence d’éléments passe et se transforme d’une manière ou d’une autre.

Un flux peut être créé à partir de diverses sources, notamment :

  • Une collection telle qu’une liste ou un ensemble.
  • Un tableau.
  • À partir de fichiers et de leurs chemins à l’aide d’un tampon.

Il existe deux types d’opérations effectuées dans un flux : –

  • Opérations intermédiaires
  • Opérations terminales

Opérations intermédiaires vs terminales

Chaque opération intermédiaire renvoie un nouveau flux en interne qui transforme l’entrée à l’aide de la méthode spécifiée. Rien n’est réellement traversé ; Au lieu de cela, il est transmis au flux suivant. Ce n’est qu’au niveau du terminal que le flux est traversé pour obtenir le résultat souhaité.

Par exemple, vous avez une liste de 10 numéros que vous souhaitez filtrer, puis associer à quelque chose. Tous les éléments de la liste ne seront pas parcourus immédiatement pour obtenir le résultat filtré et le mapper sur autre chose. Au lieu de cela, les éléments individuels seront vérifiés et s’ils remplissent la condition, ils seront mappés. De nouveaux flux pour chaque élément.

L’opération de mappage sera effectuée sur les éléments individuels qui satisfont le filtre et non sur la liste entière. Et lors de l’opération terminale, ils sont parcourus et combinés en un seul résultat.

Après avoir effectué l’opération de terminal, le flux est consommé et ne peut plus être utilisé. Vous devez créer un nouveau flux pour effectuer à nouveau les mêmes opérations.

Source : Le développeur ennuyé

Avec une compréhension au niveau de la surface du fonctionnement des flux, passons aux détails de mise en œuvre des flux en Java.

#1. Un flux vide

Créez un flux vide à l’aide de la méthode empty de l’API Stream.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream emptyStream = Stream.empty();
        System.out.println(emptyStream.count());
    }
}

Output:
0

Ici, si vous imprimez le nombre d’éléments dans ce flux, vous obtenez 0 en sortie car il s’agit d’un flux vide sans éléments. Les flux vides sont très utiles pour éviter les exceptions de pointeur null.

#2. Diffuser à partir des collections

Les collections telles que Lists et Set exposent une méthode stream() qui vous permet de créer un flux à partir d’une collection. Le flux créé peut ensuite être parcouru pour obtenir le résultat final.

ArrayList<Integer> list = new ArrayList();

for (int i = 0; i < 20; i++) {
    list.add(i+1);
}

System.out.println(list);

Stream<Integer> filtered = list.stream().filter(num -> num > 10);
filtered.forEach(num -> System.out.println(num + " "));

#Output

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
11 
12 
13 
14 
15 
16 
17 
18 
19 
20

#3. Diffuser à partir de baies

La méthode Arrays.stream() est utilisée pour créer un flux à partir d’un tableau.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] stringArray = new String[]{"this", "is", "toptips.fr"};
        Arrays.stream(stringArray).forEach(item -> System.out.print(item + " "));
    }
}

#Output

this is toptips.fr

Vous pouvez également spécifier l’index de début et de fin des éléments pour créer un flux. L’index de début est inclusif, tandis que l’index de fin est exclusif.

String[] stringArray = new String[]{"this", "is", "toptips.fr"};
Arrays.stream(stringArray, 1, 3).forEach(item -> System.out.print(item + " "));

Output:
is toptips.fr

#4. Trouver les nombres min et max à l’aide de Streams

L’accès au nombre maximum et minimum d’une collection ou d’un tableau peut être fait en utilisant des comparateurs en Java. Les méthodes min() et max() acceptent un comparateur et renvoient un objet Optional.

Un objet optionnel est un objet conteneur qui peut contenir ou non une valeur non nulle. S’il contient une valeur non nulle, l’appel de la méthode get() renverra la valeur.

import java.util.Arrays;
import java.util.Optional;

public class MinMax {
    public static void main(String[] args) {
        Integer[] numbers = new Integer[]{21, 82, 41, 9, 62, 3, 11};

        Optional<Integer> maxValue = Arrays.stream(numbers).max(Integer::compare);
        System.out.println(maxValue.get());

        Optional<Integer> minValue = Arrays.stream(numbers).min(Integer::compare);
        System.out.println(minValue.get());
    }
}

#Output
82
3

Ressources d’apprentissage

Maintenant que vous avez une compréhension de base de Streams en Java, voici 5 ressources pour vous familiariser avec Java 8 :

#1. Java 8 en action

Ce livre est un guide présentant les nouvelles fonctionnalités de Java 8, y compris les flux, les lambdas et la programmation de style fonctionnel. Des quiz et des questions de vérification des connaissances font également partie du livre, ce qui vous aidera à récupérer ce que vous avez appris.

Vous pouvez obtenir ce livre au format broché ainsi qu’au format livre audio sur Amazon.

#2. Java 8 Lambdas : programmation fonctionnelle pour les masses

Ce livre est spécialement conçu pour enseigner aux principaux développeurs Java SE comment l’ajout d’expressions Lambda affecte le langage Java. Il comprend des explications fluides, des exercices de code et des exemples pour vous permettre de maîtriser les expressions lambda Java 8.

Il est disponible en format broché et en édition Kindle sur Amazon.

#3. Java SE 8 pour les vraiment impatients

Si vous êtes un développeur Java SE expérimenté, ce livre vous guidera à travers les améliorations apportées à Java SE 8, l’API de flux, l’ajout d’expressions lambda, les améliorations de la programmation simultanée en Java et certaines fonctionnalités de Java 7 que la plupart des gens ne connaissent pas. t savoir.

Il est uniquement disponible en format broché sur Amazon.

#4. Apprendre la programmation fonctionnelle Java avec Lambdas & Streams

Ce cours d’Udemy explore les bases de la programmation fonctionnelle en Java 8 et 9. Les expressions Lambda, les références de méthodes, les flux et les interfaces fonctionnelles sont les concepts sur lesquels ce cours se concentre.

Il comprend également un tas de puzzles Java et d’exercices liés à la programmation fonctionnelle.

#5. Bibliothèque de classes Java

La bibliothèque de classes Java fait partie de la spécialisation Core Java proposée par Coursera. Il vous apprendra à écrire du code de type sécurisé à l’aide de Java Generics, à comprendre la bibliothèque de classes composée de plus de 4000 classes, à travailler avec des fichiers et à gérer les erreurs d’exécution. Cependant, il y a quelques prérequis pour suivre ce cours :

  • Introduction à Java
  • Introduction à la programmation orientée objet avec Java
  • Hiérarchies orientées objet en Java

Derniers mots

L’API Java Stream et l’introduction des fonctions Lambda dans Java 8 ont simplifié et amélioré beaucoup de choses en Java, telles que l’itération parallèle, les interfaces fonctionnelles, moins de code, etc.

Cependant, les flux ont certaines limites ; leur plus grande limitation est qu’ils ne peuvent être consommés qu’une seule fois. Si vous êtes un développeur Java, les ressources mentionnées ci-dessus peuvent vous aider à comprendre ces sujets de manière beaucoup plus détaillée, alors assurez-vous de les consulter.

Vous voudrez peut-être également en savoir plus sur la gestion des exceptions en Java.