Les flux sont-ils toujours plus lents que les collectes traditionnelles pour des opérations simples ?

Performances du flux Java 8 par rapport aux performances du flux. Collections traditionnelles

Vous vous êtes récemment aventuré dans Java 8 et avez mené une analyse comparative informelle pour comparer les performances de son API Stream par rapport aux collections classiques. Votre test consiste à filtrer une liste d'entiers, à extraire la racine carrée des nombres pairs et à stocker les résultats dans une liste double. Cependant, vous remettez en question la validité de votre test et êtes impatient de clarifier les véritables implications en termes de performances.

Évaluation du test de référence

Vos résultats initiaux, qui indiquaient des flux être plus lent que les collectes, a soulevé des inquiétudes. Pour garantir une évaluation plus fiable, il est essentiel de corriger les erreurs potentielles et d'effectuer un test équitable. Voici quelques considérations :

• Utilisation de LinkedList : LinkedList n'est pas un choix optimal pour la liste de résultats car elle manque d'accès aléatoire efficace. Envisagez plutôt d'utiliser ArrayList.
• Méthodologie d'analyse comparative : l'analyse comparative manuelle peut être sujette à des inexactitudes. Utilisez un cadre d'analyse comparative tel que JMH (Java Microbenchmarking Harness) pour fournir des mesures plus précises et plus fiables.

Résultats d'analyse comparative appropriés

Suite à ces recommandations, revisitons les évaluation des performances à l'aide de JMH et de stratégies d'analyse comparative améliorées :

@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@OperationsPerInvocation(StreamVsVanilla.N)
public class StreamVsVanilla {
    public static final int N = 10000;

    static List<Integer> sourceList = new ArrayList<>();
    static {
        for (int i = 0; i < N; i++) {
            sourceList.add(i);
        }
    }

    @Benchmark
    public List<Double> vanilla() {
        List<Double> result = new ArrayList<>(sourceList.size() / 2 + 1);
        for (Integer i : sourceList) {
            if (i % 2 == 0){
                result.add(Math.sqrt(i));
            }
        }
        return result;
    }

    @Benchmark
    public List<Double> stream() {
        return sourceList.stream()
                .filter(i -> i % 2 == 0)
                .map(Math::sqrt)
                .collect(Collectors.toCollection(
                    () -> new ArrayList<>(sourceList.size() / 2 + 1)));
    }
}

Résultats :

Benchmark                   Mode   Samples         Mean   Mean error    Units
StreamVsVanilla.stream      avgt        10       17.588        0.230    ns/op
StreamVsVanilla.vanilla     avgt        10       10.796        0.063    ns/op

Résultats

Contrairement à Selon les premiers résultats, le benchmark JMH montre clairement que l'approche de collecte traditionnelle est nettement plus rapide que l'approche de flux dans ce scénario particulier.

Conclusion

Sur la base de ces analyses comparatives améliorées résultats, nous pouvons conclure que :

• Les flux ne sont pas intrinsèquement plus lents que les collections. Cependant, leur surcharge peut dépasser les avantages dans certains cas d'utilisation, tels que de simples opérations de filtrage et de mappage.
• Les flux offrent des avantages significatifs en termes de simplicité et de maintenabilité du code. Ils simplifient les pipelines de traitement des données et réduisent le code passe-partout.
• Pour les chemins de code critiques en termes de performances, il est toujours conseillé d'effectuer une analyse comparative approfondie et de prendre en compte les exigences spécifiques de votre application.

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!