Arroyos o los bucles

Jvdev:

La cuestión es más general y no está relacionado con los pros y los contras de ambos estilos. La pregunta se debe prefiero siempre que sea posible utilizar en lugar de corriente para los bucles, ya que es declarativa con una buena legibilidad?

Estaba discutiendo con mi colega sobre los pros y los contras de la utilización de los arroyos y de bucle. Estoy de acuerdo que debemos preferir corrientes en el 90% del tiempo, pero creo que hay algunos casos en que es mejor usar para el bucle en lugar de corriente.

Por ejemplo que necesitaba para llevar a cabo varias operaciones de recolección de elementos y estas operaciones podría lanzar excepción revisada. Durante el funcionamiento si occurres de excepción para cualquier elemento que quería salir de la ejecución en todo lo que he usado para el lazo para que lo envolvió en bloque try / catch. Mi colega no estaba satisfecho porque el resultado tuvo en dos ocasiones más líneas que si yo usaría corriente en su lugar. Reescribí mediante la creación de interfaces funcionales propios personalizados que arroja excepción revisada y métodos estáticos para convertirlos en lanzar excepciones sin marcar (ejemplos aquí ) y, finalmente, se veía así:

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

Estaba feliz porque tuvo líneas de código en el dos veces menos.

Es simple ejemplo y no se ve tan mal, pero bucle de edad aquí es más simple y más rápida manera de hacer frente a ese caso creo. ¿Hay que tienden a utilizar corrientes en todas partes es posible?

Cuenta :

Joshua Bloch, autor de "Effective Java", tiene una buena charla que toca sobre cuándo utilizar corrientes. Empezar a ver alrededor de 30:30 de la sección "Uso arroyos con criterio".

Aunque esto es en gran parte basada opinión, sostiene que no desea comenzar inmediatamente convertir todos sus bucles de procedimiento en corrientes, pero que realmente quiere un enfoque equilibrado. Se proporciona al menos un método de ejemplo en el que al hacerlo crea código que es más difícil de entender. También sostiene que no hay una respuesta correcta en muchos casos si escribir es de procedimiento o de una manera más funcional, y es dependiente del contexto (y yo diría lo que el equipo ha decidido hacer colectivamente podría desempeñar un papel). Él tiene los ejemplos en GitHub , y todos los ejemplos a continuación son de su repositorio GitHub .

Aquí está el ejemplo que ofrece anagrama de su método 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);
    }
}

Y aquí está utilizando arroyos,

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

Sostiene a un tercer enfoque equilibrado, que utiliza 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);
    }
}