Un guide de Java pour les boucles


  • FrançaisFrançais


  • En programmation, vous avez souvent besoin que votre code itère sur un ensemble de données pour traiter chaque élément individuellement. Vous utilisez des structures de contrôle pour diriger le flux d’un programme, et la façon dont vous indiquez à votre code ce qu’il faut faire est de définir une condition qu’il peut tester. Par exemple, vous pouvez écrire du code pour redimensionner une image jusqu’à ce que toutes les images aient été redimensionnées une fois. Mais comment savez-vous combien d’images il y a? Un utilisateur peut avoir cinq images et un autre peut en avoir 100. Comment écrivez-vous du code qui peut s’adapter à des cas d’utilisation uniques ? Dans de nombreux langages, Java inclus, une option est la boucle for. Une autre option pour Java est la méthode Stream. Cet article couvre les deux.

    Pour la boucle

    Une boucle for prend une quantité connue d’éléments et s’assure que chaque élément est traité. Un “élément” peut être un nombre, ou il peut s’agir d’un tableau contenant plusieurs entrées, ou de n’importe quel type de données Java. Ceci décrit essentiellement un compteur :

    Par exemple, supposons que vous ayez trois éléments et que vous souhaitiez que Java traite chacun d’eux. Commencez votre compteur (appelez-le c) à 0 car Java démarre l’index des tableaux à 0. Définissez la valeur d’arrêt sur c < 3 ou alors c ⇐ 2. Enfin, incrémentez le compteur de 1. Voici un exemple de code :

    package com.opensource.example;
    
    public class Main {
      public static void main(String[] args) {
    
          String[] myArray = {"zombie", "apocalypse", "alert" };
    
        for (int i = 0; i < 3; i++) {
            System.out.printf("%s ", myArray[i]);
        }
      }
    }

    Exécutez le code pour vous assurer que les trois éléments sont traités :

    $ java ./for.java
    zombie apocalypse alert

    Les conditions sont flexibles. Vous pouvez décrémenter au lieu d’incrémenter, et vous pouvez incrémenter (ou décrémenter) de n’importe quel montant.

    La boucle for est une construction courante dans la plupart des langages. Cependant, la plupart des langages de programmation sont activement développés et Java s’améliore sans cesse. Il existe une nouvelle façon d’itérer sur les données, et elle s’appelle Java Stream.

    Flux Java

    L’interface Java Stream est une fonctionnalité de Java fournissant un accès fonctionnel à une collection de données structurées. Au lieu de créer un compteur pour “parcourir” vos données, vous utilisez une méthode Stream pour interroger les données :

    package com.opensource.example;
    
    import java.util.Arrays;
    import java.util.stream.Stream;
    
    public class Example {
      public static void main(String[] args) {
        // create an array
        String[] myArray = new String[]{"plant", "apocalypse", "alert"};
    
        // put array into Stream
        Stream<String> myStream = Arrays.stream(myArray);
    
        myStream.forEach(e -> System.out.println(e));
        }
      }

    Dans cet exemple de code, vous importez le java.util.stream.Stream bibliothèque pour accéder à la construction Stream, et java.util.Arrays pour déplacer un tableau dans le Stream.

    Dans le code, vous créez un tableau comme d’habitude. Ensuite, vous créez un flux appelé myStream et mettez-y les données de votre tableau. Ces deux étapes sont généralement typiques de l’utilisation de Stream : vous avez des données, vous placez donc les données dans un Stream afin de pouvoir les analyser.

    Ce que vous faites avec le Stream dépend de ce que vous voulez réaliser. Les méthodes de flux sont bien documentées dans les documents Java, mais pour imiter l’exemple de base de la boucle for, il est logique d’utiliser le forEach ou alors forEachOrdered méthode, qui itère sur chaque élément du Stream. Dans cet exemple, vous utilisez une expression lambda pour créer un paramètre, qui est transmis à une instruction print :

    $ java ./stream.java
    plant
    apocalypse
    alert

    Quand utiliser le flux

    Les flux n’existent pas vraiment pour remplacer les boucles for. En fait, les flux sont conçus comme des constructions éphémères qui n’ont pas besoin d’être stockées en mémoire. Ils sont destinés à recueillir des données pour analyse, puis disparaissent.

    Par exemple, regardez ce qui se passe si vous essayez d’utiliser un Stream deux fois :

    package com.opensource.example;
    
    import java.util.Arrays;
    import java.util.stream.Stream;
    
    public class Example {
      public static void main(String[] args) {
        // create an array
        String[] myArray = new String[]{"plant", "apocalypse", "alert"};
    
        // put array into Stream
        Stream<String> myStream = Arrays.stream(myArray);
    
        long myCount = myStream.count();
        System.out.println(myCount);
        }
      }

    Cela ne fonctionnera pas, et c’est intentionnel :

    $ java ./stream.java
    Exception in thread "main"
    stream has already been operated upon or closed

    Une partie de la philosophie de conception de Java Stream consiste à intégrer des données dans votre code. Vous appliquez ensuite des filtres à l’avance plutôt que d’écrire un tas d’instructions if-then-else dans une tentative désespérée de trouver les données que vous voulez réellement, de traiter les données, puis de supprimer le Stream. C’est similaire à un tube Linux, dans lequel vous envoyez la sortie d’une application à votre terminal uniquement pour la filtrer via grep afin que vous puissiez ignorer toutes les données dont vous n’avez pas besoin.

    Voici un exemple simple de filtre pour éliminer toute entrée dans un ensemble de données qui ne commence pas par un a:

    package com.opensource.example;
    
    import java.util.Arrays;
    import java.util.stream.Stream;
    
    public class Example {
      public static void main(String[] args) {
        String[] myArray = new String[]{"plant", "apocalypse", "alert"};
        Stream<String> myStream = Arrays.stream(myArray).filter(s -> s.startsWith("a"));
        myStream.forEach(e -> System.out.println(e));
        }
      }

    Voici la sortie :

    $ java ./stream.java
    apocalypse
    alert

    Pour les données que vous avez l’intention d’utiliser comme ressource dans votre code, utilisez une boucle for.

    Pour les données que vous souhaitez ingérer, analyser et oublier, utilisez un Stream.

    Itération

    L’itération est courante en programmation, et que vous utilisiez une boucle for ou un Stream, comprendre la structure et les options dont vous disposez signifie que vous pouvez prendre des décisions intelligentes sur la façon de traiter les données en Java.

    Pour une utilisation avancée de Streams, lisez l’article de Chris Hermansen Vous n’aimez pas les boucles ? Essayez les flux Java.

    Source

    N'oubliez pas de voter pour cet article !
    1 Star2 Stars3 Stars4 Stars5 Stars (No Ratings Yet)
    Loading...

    La Rédaction

    L'équipe rédactionnnelle du site

    Pour contacter personnellement le taulier :

    Laisser un commentaire

    Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

    Copy code