L'API Streams de Java 8 est-elle plus rapide que les collections traditionnelles dans les scénarios critiques en termes de performances ?

Java 8 : analyse des performances des flux par rapport aux collections

Évaluation des performances de l'API Streams récemment introduite dans Java 8 par rapport à l'approche traditionnelle des collections est un aspect crucial pour les développeurs. Pour fournir des informations, un premier benchmark a été réalisé, qui a soulevé des questions sur l'efficacité comparative de ces deux méthodes.

Configuration et résultats du benchmark

Le benchmark impliquait de filtrer un échantillon important liste d'entiers et calcul de la racine carrée des nombres pairs, stockage des résultats dans une liste de Double. L'extrait de code ci-dessous illustre la mise en œuvre :

<code class="java">    // Source list initialization
    List<Integer> sourceList = new ArrayList<>();
    for (int i = 1; i < 1000000; i++) {
        sourceList.add(i);
    }

    // Collections approach
    List<Double> resultCollection = new LinkedList<>();
    long startTimeCollection = System.nanoTime();
    // Iterate through the list and perform calculations
    for (Integer i : sourceList) {
        if (i % 2 == 0) {
            resultCollection.add(Math.sqrt(i));
        }
    }
    long elapsedTimeCollection = System.nanoTime() - startTimeCollection;


    // Stream approach
    Stream<Integer> stream = sourceList.stream();
    long startTimeStream = System.nanoTime();
    // Filter even numbers and calculate square roots
    resultStream = stream.filter(i -> i % 2 == 0)
                        .map(i -> Math.sqrt(i))
                        .collect(Collectors.toList());
    long elapsedTimeStream = System.nanoTime() - startTimeStream;

    // Parallel stream approach
    stream = sourceList.stream().parallel();
    long startTimeParallelStream = System.nanoTime();
    resultParallelStream = stream.filter(i -> i % 2 == 0)
                                .map(i -> Math.sqrt(i))
                                .collect(Collectors.toList());
    long elapsedTimeParallelStream = System.nanoTime() - startTimeParallelStream;</code>

Les résultats sur une machine double cœur ont révélé que :

• L'approche des collections s'est déroulée sensiblement plus rapidement, prenant environ 0,094 seconde.
• L'approche par flux a montré des performances plus lentes, nécessitant environ 0,201 seconde.
• L'approche par flux parallèle a présenté des performances similaires à celles de l'approche par flux, se terminant en 0,357 seconde.

Analyse des résultats de référence

Sur la base de ces premiers résultats, il a été initialement conclu que les flux étaient plus lents que les collections, et que même le parallélisme ne parvenait pas à améliorer les performances. Cependant, la méthodologie de référence utilisée a soulevé des inquiétudes quant à des défauts potentiels.

Vérification améliorée des performances

Pour répondre à ces préoccupations, la référence a été révisée avec les améliorations suivantes :

• Exécution : le benchmark a été exécuté 1 000 fois après le préchauffage de la JVM pour stabiliser les performances.
• Profilage : JMH (Java Microbenchmarking Harness) a été utilisé pour exécuter le benchmark avec précision et collecter des données de performances.

Résultats du benchmark mis à jour

Le benchmark révisé a donné les résultats suivants :

• Approche des collections : durée moyenne de 0,207 seconde
• Approche flux : temps moyen de 0,098 secondes
• Approche flux parallèle : temps moyen de 0,168 secondes

Dans ce benchmark révisé, les flux ont surperformé les collections, contrairement aux conclusions initiales. Le temps d'exécution plus rapide de l'approche stream peut être attribué aux optimisations JIT et à la génération de code améliorée par le compilateur.

Conclusion

Sur la base de ces résultats mis à jour, il peut être a conclu que les flux dans Java 8 offrent à la fois une commodité de codage et des améliorations de performances par rapport aux collections traditionnelles. Bien que les flux ne soient pas toujours supérieurs, leur utilisation peut simplifier considérablement le code et améliorer l'efficacité dans de nombreux scénarios.

Bonnes pratiques

Pour exploiter efficacement les avantages des flux, considérez les bonnes pratiques suivantes :

• Utilisez des expressions lambda en ligne pour plus de concision et d'efficacité.
• Évitez les listes intermédiaires inutiles et concentrez-vous sur l'utilisation directe d'une collection cible.
• Explorez les fonctionnalités de flux parallèle pour optimiser les performances dans certains situations.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!