Simplifying Collection Processing with Java 8 Stream API

Java 8 introduced lambda expressions and the Stream API, which together enable declarative processing of collections, making code more concise and readable.

Stream simplifies code

Given a requirement to process dishes from a database—filter calories < 400, sort, and extract names—pre‑Java 7 code requires explicit loops, conditionals, and manual list management.

public List<String> beforeJava7(List<Dish> dishList) {
    List<Dish> lowCaloricDishes = new ArrayList<>();
    // 1. filter
    for (Dish dish : dishList) {
        if (dish.getCalories() < 400) {
            lowCaloricDishes.add(dish);
        }
    }
    // 2. sort
    Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
        @Override
        public int compare(Dish o1, Dish o2) {
            return Integer.compare(o1.getCalories(), o2.getCalories());
        }
    });
    // 3. map to names
    List<String> lowCaloricDishesName = new ArrayList<>();
    for (Dish d : lowCaloricDishes) {
        lowCaloricDishesName.add(d.getName());
    }
    return lowCaloricDishesName;
}

With Java 8 the same logic collapses to a five‑line stream pipeline:

private List<String> afterJava8(List<Dish> dishList) {
    return dishList.stream()
        .filter(d -> d.getCalories() < 400)
        .sorted(comparing(Dish::getCalories))
        .map(Dish::getName)
        .collect(Collectors.toList());
}

For a new requirement—group dishes by type into a Map<Type, List<Dish>> —the pre‑Java 8 approach uses nested loops and manual map handling, while Java 8 reduces it to a single line:

private static Map<Type, List<Dish>> afterJdk8(List<Dish> dishList) {
    return dishList.stream().collect(groupingBy(Dish::getType));
}

What is a Stream?

A stream is a sequence of elements generated from a data source (arrays, files, collections, functions). It is not a data structure; it does not store elements but provides a pipeline for computation.

How to create streams

From a collection:

List<Integer> list = Arrays.asList(1,2,3,4,5); Stream<Integer> s = list.stream();

From an array:

int[] arr = new int[]{1,2,3,4,5}; IntStream s = Arrays.stream(arr);

From values: Stream<Integer> s = Stream.of(1,2,3,4,5); From a file:

Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset());

From functions: Stream<Integer> s = Stream.iterate(0, n -> n + 2).limit(5); and

Stream<Double> s = Stream.generate(Math::random).limit(5);

Stream operations

Operations are divided into intermediate (lazy) and terminal (eager) stages.

Intermediate operations

filter : stream.filter(i -> i > 3) distinct : removes duplicates.

limit : caps the number of elements.

skip : skips a number of elements.

map : transforms each element, e.g., list.stream().map(String::length).

flatMap : flattens nested streams.

match operations: allMatch, anyMatch, noneMatch.

Terminal operations

count / collect(counting()) – count elements.

findFirst / findAny – retrieve an element.

reduce – combine elements, e.g., sum.

min / max – obtain extreme values.

collect – gather results into collections, maps, or statistics (e.g., groupingBy, partitioningBy, joining, summarizingInt).

forEach – iterate with side effects.

Advanced collectors

Examples include groupingBy for multi‑level classification, partitioningBy for boolean splits, and summarizingInt for combined sum/average/min/max statistics.

Conclusion

Using the Stream API dramatically reduces boilerplate, improves readability, and encourages a declarative programming style. However, mixing declarative streams with imperative code should be avoided to maintain clarity.