Cours d'eau ou pour les boucles

Jvdev:

La question est plus générale et ne sont pas liés à des avantages et des inconvénients des deux styles. La question est que je devrais préférer chaque fois qu'il est possible d'utiliser un jet au lieu de pour les boucles , car il est déclarative avec une bonne lisibilité?

Je discutais avec mon collègue sur les avantages et les inconvénients de l'utilisation des flux et pour la boucle. Je suis d'accord que nous devrions préférer les flux dans 90% du temps, mais je crois qu'il ya des cas où il est préférable d'utiliser pour la boucle au lieu de cours d'eau.

Par exemple , je devais effectuer plusieurs opérations sur la collecte d'éléments et ces opérations pourraient jeter exception vérifiée. Au cours de fonctionnement si occurres d'exception pour tout élément que je voulais arrêter l'exécution du tout si je boucle pour elle et l'enveloppa dans bloc try / catch. Mon collègue n'a pas été satisfaite parce résultat a deux fois plus de lignes que si j'utiliser au lieu courant. Je réécris en créant propres interfaces fonctionnelles personnalisées et lancers francs cochés exception méthodes statiques pour les convertir en jetant exception non contrôlée (exemples ici ) et , enfin , il ressemblait à ceci:

try {
        Map<String, String> someResult= elements.stream()
                .filter(throwingPredicateWrapper(element-> client.hasValue(element)))
                .collect(
                        Collectors.toMap(Function.identity(),
                                throwingFunctionWrapper(element -> client.getValue(element))));

        return someResult;
    } catch (Exception e) {
        LOGGER.error("Error while processing", e);
    }

Il était heureux parce qu'il a pris des lignes de code en deux moins de temps.

Il est par exemple simple et il ne semble pas si mal mais vieille boucle ici est plus moyen simple et plus rapide pour traiter ce cas, je crois. Faut-il tendance à utiliser des ruisseaux partout où il est possible?

Facture :

Joshua Bloch, auteur de « Java efficace », a une bonne conférence qui touche quand utiliser les flux. Commencer à regarder autour de 30:30 pour sa section « Utilisation des flux judicieusement ».

Bien que ce soit en grande partie fondée sur des opinions, soutient - il que vous ne voulez pas commencer immédiatement tourner toutes vos boucles de procédure en cours d' eau, mais vous voulez vraiment une approche équilibrée. Il fournit au moins un exemple méthode lorsque cela crée un code qui est plus difficile à comprendre. Il soutient également qu'il n'y a pas de réponse dans de nombreux cas que de l' écrire de procédure ou d'une manière plus fonctionnelle, et il dépend du contexte (et je dirais que l'équipe a décidé de faire pourrait collégialement jouer un rôle). Il a des exemples sur GitHub , et tous les exemples ci - dessous sont de son dépôt GitHub .

Voici est l'exemple qu'il donne de sa méthode itérative anagrammes,

// Prints all large anagram groups in a dictionary iteratively (Page 204)
public class IterativeAnagrams {
    public static void main(String[] args) throws IOException {
        File dictionary = new File(args[0]);
        int minGroupSize = Integer.parseInt(args[1]);

        Map<String, Set<String>> groups = new HashMap<>();
        try (Scanner s = new Scanner(dictionary)) {
            while (s.hasNext()) {
                String word = s.next();
                groups.computeIfAbsent(alphabetize(word),
                        (unused) -> new TreeSet<>()).add(word);
            }
        }

        for (Set<String> group : groups.values())
            if (group.size() >= minGroupSize)
                System.out.println(group.size() + ": " + group);
    }

    private static String alphabetize(String s) {
        char[] a = s.toCharArray();
        Arrays.sort(a);
        return new String(a);
    }
}

Et ici , il utilise cours d' eau,

// Overuse of streams - don't do this! (page 205)
public class StreamAnagrams {
    public static void main(String[] args) throws IOException {
        Path dictionary = Paths.get(args[0]);
        int minGroupSize = Integer.parseInt(args[1]);

        try (Stream<String> words = Files.lines(dictionary)) {
            words.collect(
                    groupingBy(word -> word.chars().sorted()
                            .collect(StringBuilder::new,
                                    (sb, c) -> sb.append((char) c),
                                    StringBuilder::append).toString()))
                    .values().stream()
                    .filter(group -> group.size() >= minGroupSize)
                    .map(group -> group.size() + ": " + group)
                    .forEach(System.out::println);
        }
    }
}

Il plaide pour une troisième approche équilibrée, qui utilise à la fois,

// Tasteful use of streams enhances clarity and conciseness (Page 205)
public class HybridAnagrams {
    public static void main(String[] args) throws IOException {
        Path dictionary = Paths.get(args[0]);
        int minGroupSize = Integer.parseInt(args[1]);

        try (Stream<String> words = Files.lines(dictionary)) {
            words.collect(groupingBy(word -> alphabetize(word)))
                    .values().stream()
                    .filter(group -> group.size() >= minGroupSize)
                    .forEach(g -> System.out.println(g.size() + ": " + g));
        }
    }

    private static String alphabetize(String s) {
        char[] a = s.toCharArray();
        Arrays.sort(a);
        return new String(a);
    }
}