Rios ou para loops

Jvdev:

A questão é mais geral e não está relacionada com prós e contras de ambos os estilos. A questão é que eu deveria preferir sempre que é possível usar fluxo em vez de loops porque é declarativa com uma boa legibilidade?

Eu estava discutindo com o meu colega sobre prós e contras do uso de córregos e de loop. Concordo que devemos preferir correntes em 90% do tempo, mas eu acredito que há alguns casos em que é melhor usar para o laço em vez de fluxo.

Por exemplo, eu precisava para executar várias operações na coleção de elementos e estas operações poderiam lançar exceção verificada. Durante a operação, se occurres exceção para qualquer elemento que eu quis parar a execução de todo assim que eu usei para o laço para ele e envolveu-o no bloco try / catch. O meu colega não estava satisfeito porque o resultado levou em duas vezes mais linhas do que se eu usaria fluxo vez. Eu reescrevi-lo criando próprios personalizados de interfaces funcionais que lança verificados exceção e métodos estáticos para convertê-los em lançando exceção desmarcada (exemplos aqui ) e, finalmente, ficou assim:

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);
    }

Ele estava feliz porque levou linhas de código em duas vezes menos.

É um exemplo simples e não parece tão ruim, mas laço velho aqui é mais simples e mais rápida maneira de lidar com isso caso eu acredito. Devemos tendem a usar Streams em toda parte é possível?

Conta :

Joshua Bloch, autor de "Effective Java", tem uma boa conversa que toca em quando usar correntes. Começar a assistir ao redor 30:30 para sua seção sobre "Utilização córregos judiciosamente".

Embora esta seja amplamente opinião com base, ele argumenta que você não quer começar imediatamente transformando todos os seus laços processuais em córregos, mas você realmente quer uma abordagem equilibrada. Ele fornece pelo menos um método de exemplo em que isso cria código que é mais difícil de entender. Ele também argumenta que não há nenhuma resposta certa em muitos casos se para escrevê-lo processual ou de uma forma mais funcional, e é dependente do contexto (e eu diria que a equipe decidiu fazer corporativamente pode desempenhar um papel). Ele tem os exemplos no GitHub , e todos os exemplos abaixo são do seu repositório GitHub .

Aqui está o exemplo que ele fornece de seu método anagrama iterativo,

// 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);
    }
}

E aqui ele está usando córregos,

// 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);
        }
    }
}

Ele argumenta para uma terceira abordagem equilibrada, que usa tanto,

// 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);
    }
}