Java 8 Uso de Stream básico

By | 04/13/2017

Podemos definir Streams como una secuencia de funciones que se ejecutan una detrás de otra, de forma anidada.

Las operaciones sobre Stream pueden ser intermedias o finales. En el caso de ser intermedias (filter, sorted, map) stream devolverá nuevamente otro stream permitiendo la continuidad de pasos o funciones sobre ella misma. Esto es llamado ‘pipelining’.

In computing, a pipeline is a set of data processing elements connected in series, where the output of one element is the input of the next one. The elements of a pipeline are often executed in parallel or in time-sliced fashion; in that case, some amount of buffer storage is often inserted between elements.
Wikipedia

Estas son algunas funciones intermedias:

        // Intermediate operations
        Stream<Product> stream = products.stream();
        Stream<Product> filterStream = stream.filter(p -> "B".equals(p.getType()));
        Stream<Product> sorted = filterStream.sorted(comparing(Product::getPrice));

        // Final operation
        sorted.forEach(System.out::println);

Si no has leido sobre Lamndas te recomiendo una breve lectura antes.

Supongamos que quieres procesar una lista de productos y realizar diferentes procesos como:

  • recorrer la lista
  • filtrar durante el recorrido los elementos según alguna condición
  • ordenar el resultado anterior
  • mostrar el resultado

Harías estas operaciones de forma tradicional así:


        List<Product> products = getProducts();
        List<Product> resultFilter = new ArrayList<>();

        // foreach filter
        for(Product p : products) {
            if("B".equals(p.getType())){
                resultFilter.add(p);
            }
        }
        // sort
        Collections.sort(resultFilter, new Comparator<Product>() {
            @Override
            public int compare(Product p1, Product p2) {
                return p1.getPrice().compareTo(p2.getPrice());
            }
        });
        // print
        for(Product p: resultFilter) {
            System.out.println(p);
        }  

La clase Product que usas es:


public class Product {

    private long id;
    private String name;
    private String type;
    private Double price;

    // get and set...
}

Como usar Stream con Java 8

Con Java 8 utilizando Streams y Lambdas haces las mismas operaciones anteriores de este modo:

        List<Product> products = getProducts();

        // filter + sort + print
        products.stream().filter(p ->"B".equals(p.getType())).
                sorted(comparing(Product::getPrice)).
                forEach(System.out::println);

Puedes observar rápidamente la reducción en líneas de código y complejidad con este simple ejemplo.

Ejemplos de uso simple Stream con Java 8

Observa esta operaciones usando Stream y como pueden ayudarte

       List<Product> products = getProducts();

        // limit and foreach
        products.stream().limit(10).forEach(System.out::println);

        // filter and count
        long count = products.stream().filter(product -> product.getPrice() > 200d).count();
        System.out.println(count);

        // collect ids
        List<Long> ids = products.stream().filter(product -> product.getPrice() > 200d).
                map(p -> p.getId()).collect(Collectors.toList());
        ids.forEach(System.out::print);  // print this ids..

        //statistics
        DoubleSummaryStatistics doubleSummaryStatistics = products.stream().mapToDouble(p -> p.getPrice()).summaryStatistics();
        System.out.println(doubleSummaryStatistics.getSum());
        System.out.println(doubleSummaryStatistics.getMax());
        System.out.println(doubleSummaryStatistics.getMin());

Referencias:
http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html

Descarga este código completo

Compartir esto:

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *