Stream Operations

Stream Filter and Map

Processing collections often requires selecting specific items and transforming them. Stream's filter and map operations let you declaratively express "keep items matching X, then transform each to Y" without manual loops or intermediate collections.

Filtering

The filter operation takes a Predicate<T> and returns a stream containing only elements where the predicate returns true.

minValue
Filter.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Filter {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        int minValue = 5;

        List<Integer> evens = nums.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("evens: " + evens);

        List<Integer> large = nums.stream()
                .filter(n -> n > minValue)
                .collect(Collectors.toList());
        System.out.println("large: " + large);

        List<Integer> evenAndLarge = nums.stream()
                .filter(n -> n % 2 == 0)
                .filter(n -> n > 4)
                .collect(Collectors.toList());
        System.out.println("evenAndLarge: " + evenAndLarge);

    }
}

import java.util.*;
import java.util.stream.*;

public class Filter {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        int minValue = 3;

        List<Integer> evens = nums.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("evens: " + evens);

        List<Integer> large = nums.stream()
                .filter(n -> n > minValue)
                .collect(Collectors.toList());
        System.out.println("large: " + large);

        List<Integer> evenAndLarge = nums.stream()
                .filter(n -> n % 2 == 0)
                .filter(n -> n > 4)
                .collect(Collectors.toList());
        System.out.println("evenAndLarge: " + evenAndLarge);

    }
}

import java.util.*;
import java.util.stream.*;

public class Filter {
    public static void main(String[] args) {
        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
        int minValue = 7;

        List<Integer> evens = nums.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("evens: " + evens);

        List<Integer> large = nums.stream()
                .filter(n -> n > minValue)
                .collect(Collectors.toList());
        System.out.println("large: " + large);

        List<Integer> evenAndLarge = nums.stream()
                .filter(n -> n % 2 == 0)
                .filter(n -> n > 4)
                .collect(Collectors.toList());
        System.out.println("evenAndLarge: " + evenAndLarge);

    }
}

  1. nums ← [1, 2, 3, 4, 5, 6, 7, 8], minValue ← 5, evens ← [2, 4, 6, 8]

    4public class Filter {5    public static void main(String[] args) {6        List<Integer> nums→ [1, 2, 3, 4, 5, 6, 7, 8] = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);7        int minValue→ 5 = 5; //@minValue=5, 3, 789        List<Integer> evens→ [2, 4, 6, 8] = nums.stream()10                .filter(n -> n % 2 == 0)11                .collect(Collectors.toList());12        System.out.println("evens: " + evens[2, 4, 6, 8]);1314        List<Integer> large→ [6, 7, 8] = nums.stream()15                .filter(n -> n > minValue)16                .collect(Collectors.toList());17        System.out.println("large: " + large[6, 7, 8]);1819        List<Integer> evenAndLarge→ [6, 8] = nums.stream()20                .filter(n -> n % 2 == 0)21                .filter(n -> n > 4)22                .collect(Collectors.toList());23        System.out.println("evenAndLarge: " + evenAndLarge[6, 8]);
    outputevens: [2, 4, 6, 8]
large: [6, 7, 8]
evenAndLarge: [6, 8]

  1. nums ← [1, 2, 3, 4, 5, 6, 7, 8], minValue ← 3, evens ← [2, 4, 6, 8]

    4public class Filter {5    public static void main(String[] args) {6        List<Integer> nums→ [1, 2, 3, 4, 5, 6, 7, 8] = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);7        int minValue→ 3 = 3;89        List<Integer> evens→ [2, 4, 6, 8] = nums.stream()10                .filter(n -> n % 2 == 0)11                .collect(Collectors.toList());12        System.out.println("evens: " + evens[2, 4, 6, 8]);1314        List<Integer> large→ [4, 5, 6, 7, 8] = nums.stream()15                .filter(n -> n > minValue)16                .collect(Collectors.toList());17        System.out.println("large: " + large[4, 5, 6, 7, 8]);1819        List<Integer> evenAndLarge→ [6, 8] = nums.stream()20                .filter(n -> n % 2 == 0)21                .filter(n -> n > 4)22                .collect(Collectors.toList());23        System.out.println("evenAndLarge: " + evenAndLarge[6, 8]);
    outputevens: [2, 4, 6, 8]
large: [4, 5, 6, 7, 8]
evenAndLarge: [6, 8]

  1. nums ← [1, 2, 3, 4, 5, 6, 7, 8], minValue ← 7, evens ← [2, 4, 6, 8]

    4public class Filter {5    public static void main(String[] args) {6        List<Integer> nums→ [1, 2, 3, 4, 5, 6, 7, 8] = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);7        int minValue→ 7 = 7;89        List<Integer> evens→ [2, 4, 6, 8] = nums.stream()10                .filter(n -> n % 2 == 0)11                .collect(Collectors.toList());12        System.out.println("evens: " + evens[2, 4, 6, 8]);1314        List<Integer> large→ [8] = nums.stream()15                .filter(n -> n > minValue)16                .collect(Collectors.toList());17        System.out.println("large: " + large[8]);1819        List<Integer> evenAndLarge→ [6, 8] = nums.stream()20                .filter(n -> n % 2 == 0)21                .filter(n -> n > 4)22                .collect(Collectors.toList());23        System.out.println("evenAndLarge: " + evenAndLarge[6, 8]);
    outputevens: [2, 4, 6, 8]
large: [8]
evenAndLarge: [6, 8]
filter An intermediate operation that keeps only elements matching a predicate, discarding the rest.

Mapping

The map operation takes a Function<T, R> and produces a new stream where each element has been transformed.

suffix
Map.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Map {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        String suffix = "!";

        List<String> upper = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("upper: " + upper);

        List<Integer> lengths = words.stream()
                .map(String::length)
                .collect(Collectors.toList());
        System.out.println("lengths: " + lengths);

        List<String> transformed = words.stream()
                .map(s -> s.toUpperCase())
                .map(s -> s + suffix)
                .collect(Collectors.toList());
        System.out.println("transformed: " + transformed);

    }
}

import java.util.*;
import java.util.stream.*;

public class Map {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        String suffix = "?";

        List<String> upper = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("upper: " + upper);

        List<Integer> lengths = words.stream()
                .map(String::length)
                .collect(Collectors.toList());
        System.out.println("lengths: " + lengths);

        List<String> transformed = words.stream()
                .map(s -> s.toUpperCase())
                .map(s -> s + suffix)
                .collect(Collectors.toList());
        System.out.println("transformed: " + transformed);

    }
}

import java.util.*;
import java.util.stream.*;

public class Map {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        String suffix = "...";

        List<String> upper = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("upper: " + upper);

        List<Integer> lengths = words.stream()
                .map(String::length)
                .collect(Collectors.toList());
        System.out.println("lengths: " + lengths);

        List<String> transformed = words.stream()
                .map(s -> s.toUpperCase())
                .map(s -> s + suffix)
                .collect(Collectors.toList());
        System.out.println("transformed: " + transformed);

    }
}

  1. words ← [apple, banana, cherry], suffix ← !, upper ← [APPLE, BANANA, CHERRY]

    4public class Map {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        String suffix→ ! = "!"; //@suffix="!", "?", "..."89        List<String> upper→ [APPLE, BANANA, CHERRY] = words.stream()10                .map(String::toUpperCase)11                .collect(Collectors.toList());12        System.out.println("upper: " + upper[APPLE, BANANA, CHERRY]);1314        List<Integer> lengths→ [5, 6, 6] = words.stream()15                .map(String::length)16                .collect(Collectors.toList());17        System.out.println("lengths: " + lengths[5, 6, 6]);1819        List<String> transformed→ [APPLE!, BANANA!, CHERRY!] = words.stream()20                .map(s -> s.toUpperCase())21                .map(s -> s + suffix)22                .collect(Collectors.toList());23        System.out.println("transformed: " + transformed[APPLE!, BANANA!, CHERRY!]);
    outputupper: [APPLE, BANANA, CHERRY]
lengths: [5, 6, 6]
transformed: [APPLE!, BANANA!, CHERRY!]

  1. words ← [apple, banana, cherry], suffix ← ?, upper ← [APPLE, BANANA, CHERRY]

    4public class Map {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        String suffix→ ? = "?";89        List<String> upper→ [APPLE, BANANA, CHERRY] = words.stream()10                .map(String::toUpperCase)11                .collect(Collectors.toList());12        System.out.println("upper: " + upper[APPLE, BANANA, CHERRY]);1314        List<Integer> lengths→ [5, 6, 6] = words.stream()15                .map(String::length)16                .collect(Collectors.toList());17        System.out.println("lengths: " + lengths[5, 6, 6]);1819        List<String> transformed→ [APPLE?, BANANA?, CHERRY?] = words.stream()20                .map(s -> s.toUpperCase())21                .map(s -> s + suffix)22                .collect(Collectors.toList());23        System.out.println("transformed: " + transformed[APPLE?, BANANA?, CHERRY?]);
    outputupper: [APPLE, BANANA, CHERRY]
lengths: [5, 6, 6]
transformed: [APPLE?, BANANA?, CHERRY?]

  1. words ← [apple, banana, cherry], suffix ← ..., upper ← [APPLE, BANANA, CHERRY]

    4public class Map {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        String suffix→ ... = "...";89        List<String> upper→ [APPLE, BANANA, CHERRY] = words.stream()10                .map(String::toUpperCase)11                .collect(Collectors.toList());12        System.out.println("upper: " + upper[APPLE, BANANA, CHERRY]);1314        List<Integer> lengths→ [5, 6, 6] = words.stream()15                .map(String::length)16                .collect(Collectors.toList());17        System.out.println("lengths: " + lengths[5, 6, 6]);1819        List<String> transformed→ [APPLE..., BANANA..., CHERRY...] = words.stream()20                .map(s -> s.toUpperCase())21                .map(s -> s + suffix)22                .collect(Collectors.toList());23        System.out.println("transformed: " + transformed[APPLE..., BANANA..., CHERRY...]);
    outputupper: [APPLE, BANANA, CHERRY]
lengths: [5, 6, 6]
transformed: [APPLE..., BANANA..., CHERRY...]
map An intermediate operation that transforms each element by applying a function.

Chaining Filter and Map

Filter and map compose naturally into pipelines. You can chain multiple operations, and they execute lazily only when a terminal operation is called.

minLength
Chain.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Chain {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "a", "banana", "b", "cherry", "");
        int minLength = 1;

        List<String> result = words.stream()
                .filter(s -> s.length() > minLength)
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("result: " + result);

        List<Integer> nums = Arrays.asList(-5, -2, 0, 3, 7);
        List<Integer> processed = nums.stream()
                .map(n -> n * n)
                .filter(n -> n > 10)
                .collect(Collectors.toList());
        System.out.println("processed: " + processed);

        List<String> names = Arrays.asList("  Alice ", " bob", "CHARLIE  ");
        List<String> normalized = names.stream()
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .map(String::toLowerCase)
                .sorted()
                .collect(Collectors.toList());
        System.out.println("normalized: " + normalized);

    }
}

import java.util.*;
import java.util.stream.*;

public class Chain {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "a", "banana", "b", "cherry", "");
        int minLength = 3;

        List<String> result = words.stream()
                .filter(s -> s.length() > minLength)
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println("result: " + result);

        List<Integer> nums = Arrays.asList(-5, -2, 0, 3, 7);
        List<Integer> processed = nums.stream()
                .map(n -> n * n)
                .filter(n -> n > 10)
                .collect(Collectors.toList());
        System.out.println("processed: " + processed);

        List<String> names = Arrays.asList("  Alice ", " bob", "CHARLIE  ");
        List<String> normalized = names.stream()
                .map(String::trim)
                .filter(s -> !s.isEmpty())
                .map(String::toLowerCase)
                .sorted()
                .collect(Collectors.toList());
        System.out.println("normalized: " + normalized);

    }
}

  1. words ← [apple, a, banana, b, cherry, ], minLength ← 1, result ← [APPLE, BANANA, CHERRY]

    4public class Chain {5    public static void main(String[] args) {6        List<String> words→ [apple, a, banana, b, cherry, ] = Arrays.asList("apple", "a", "banana", "b", "cherry", "");7        int minLength→ 1 = 1; //@minLength=1, 389        List<String> result→ [APPLE, BANANA, CHERRY] = words.stream()10                .filter(s -> s.length() > minLength)11                .map(String::toUpperCase)12                .collect(Collectors.toList());13        System.out.println("result: " + result[APPLE, BANANA, CHERRY]);1415        List<Integer> nums→ [-5, -2, 0, 3, 7] = Arrays.asList(-5, -2, 0, 3, 7);16        List<Integer> processed→ [25, 49] = nums.stream()17                .map(n -> n * n)18                .filter(n -> n > 10)19                .collect(Collectors.toList());20        System.out.println("processed: " + processed[25, 49]);2122        List<String> names→ [  Alice ,  bob, CHARLIE  ] = Arrays.asList("  Alice ", " bob", "CHARLIE  ");23        List<String> normalized→ [alice, bob, charlie] = names.stream()24                .map(String::trim)25                .filter(s -> !s.isEmpty())26                .map(String::toLowerCase)27                .sorted()28                .collect(Collectors.toList());29        System.out.println("normalized: " + normalized[alice, bob, charlie]);
    outputresult: [APPLE, BANANA, CHERRY]
processed: [25, 49]
normalized: [alice, bob, charlie]

  1. words ← [apple, a, banana, b, cherry, ], minLength ← 3, result ← [APPLE, BANANA, CHERRY]

    4public class Chain {5    public static void main(String[] args) {6        List<String> words→ [apple, a, banana, b, cherry, ] = Arrays.asList("apple", "a", "banana", "b", "cherry", "");7        int minLength→ 3 = 3;89        List<String> result→ [APPLE, BANANA, CHERRY] = words.stream()10                .filter(s -> s.length() > minLength)11                .map(String::toUpperCase)12                .collect(Collectors.toList());13        System.out.println("result: " + result[APPLE, BANANA, CHERRY]);1415        List<Integer> nums→ [-5, -2, 0, 3, 7] = Arrays.asList(-5, -2, 0, 3, 7);16        List<Integer> processed→ [25, 49] = nums.stream()17                .map(n -> n * n)18                .filter(n -> n > 10)19                .collect(Collectors.toList());20        System.out.println("processed: " + processed[25, 49]);2122        List<String> names→ [  Alice ,  bob, CHARLIE  ] = Arrays.asList("  Alice ", " bob", "CHARLIE  ");23        List<String> normalized→ [alice, bob, charlie] = names.stream()24                .map(String::trim)25                .filter(s -> !s.isEmpty())26                .map(String::toLowerCase)27                .sorted()28                .collect(Collectors.toList());29        System.out.println("normalized: " + normalized[alice, bob, charlie]);
    outputresult: [APPLE, BANANA, CHERRY]
processed: [25, 49]
normalized: [alice, bob, charlie]

FlatMap

When a mapping function produces a stream for each element (e.g., splitting strings into words), use flatMap to flatten the nested streams into a single stream.

sentences
Flatmap.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class Flatmap {
    public static void main(String[] args) {
        List<List<Integer>> nested = Arrays.asList(
                Arrays.asList(1, 2, 3),
                Arrays.asList(4, 5),
                Arrays.asList(6, 7, 8, 9)
        );

        List<Integer> flat = nested.stream()
                .flatMap(list -> list.stream())
                .collect(Collectors.toList());
        System.out.println("flat: " + flat);

        List<String> sentences = Arrays.asList("hello world", "foo bar", "test");
        List<String> allWords = sentences.stream()
                .flatMap(s -> Arrays.stream(s.split(" ")))
                .collect(Collectors.toList());
        System.out.println("allWords: " + allWords);

        List<Integer> evensFlat = nested.stream()
                .flatMap(list -> list.stream())
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("evensFlat: " + evensFlat);

    }
}

import java.util.*;
import java.util.stream.*;

public class Flatmap {
    public static void main(String[] args) {
        List<List<Integer>> nested = Arrays.asList(
                Arrays.asList(1, 2, 3),
                Arrays.asList(4, 5),
                Arrays.asList(6, 7, 8, 9)
        );

        List<Integer> flat = nested.stream()
                .flatMap(list -> list.stream())
                .collect(Collectors.toList());
        System.out.println("flat: " + flat);

        List<String> sentences = Arrays.asList("red blue", "green", "blue red");
        List<String> allWords = sentences.stream()
                .flatMap(s -> Arrays.stream(s.split(" ")))
                .collect(Collectors.toList());
        System.out.println("allWords: " + allWords);

        List<Integer> evensFlat = nested.stream()
                .flatMap(list -> list.stream())
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());
        System.out.println("evensFlat: " + evensFlat);

    }
}

  1. nested ← [[1, 2, 3], [4, 5], [6, 7, 8, 9]], flat ← [1, 2, 3, 4, 5, 6, 7, 8, 9]

    4public class Flatmap {5    public static void main(String[] args) {6        List<List<Integer>> nested→ [[1, 2, 3], [4, 5], [6, 7, 8, 9]] = Arrays.asList(7                Arrays.asList(1, 2, 3),8                Arrays.asList(4, 5),9                Arrays.asList(6, 7, 8, 9)10        );1112        List<Integer> flat→ [1, 2, 3, 4, 5, 6, 7, 8, 9] = nested.stream()13                .flatMap(list -> list.stream())14                .collect(Collectors.toList());15        System.out.println("flat: " + flat[1, 2, 3, 4, 5, 6, 7, 8, 9]);1617        List<String> sentences→ [hello world, foo bar, test] = Arrays.asList("hello world", "foo bar", "test"); //@sentences=Arrays.asList("hello world", "foo bar", "test"), Arrays.asList("red blue", "green", "blue red")18        List<String> allWords→ [hello, world, foo, bar, test] = sentences.stream()19                .flatMap(s -> Arrays.stream(s.split(" ")))20                .collect(Collectors.toList());21        System.out.println("allWords: " + allWords[hello, world, foo, bar, test]);2223        List<Integer> evensFlat→ [2, 4, 6, 8] = nested.stream()24                .flatMap(list -> list.stream())25                .filter(n -> n % 2 == 0)26                .collect(Collectors.toList());27        System.out.println("evensFlat: " + evensFlat[2, 4, 6, 8]);
    outputflat: [1, 2, 3, 4, 5, 6, 7, 8, 9]
allWords: [hello, world, foo, bar, test]
evensFlat: [2, 4, 6, 8]

  1. nested ← [[1, 2, 3], [4, 5], [6, 7, 8, 9]], flat ← [1, 2, 3, 4, 5, 6, 7, 8, 9]

    4public class Flatmap {5    public static void main(String[] args) {6        List<List<Integer>> nested→ [[1, 2, 3], [4, 5], [6, 7, 8, 9]] = Arrays.asList(7                Arrays.asList(1, 2, 3),8                Arrays.asList(4, 5),9                Arrays.asList(6, 7, 8, 9)10        );1112        List<Integer> flat→ [1, 2, 3, 4, 5, 6, 7, 8, 9] = nested.stream()13                .flatMap(list -> list.stream())14                .collect(Collectors.toList());15        System.out.println("flat: " + flat[1, 2, 3, 4, 5, 6, 7, 8, 9]);1617        List<String> sentences→ [red blue, green, blue red] = Arrays.asList("red blue", "green", "blue red");18        List<String> allWords→ [red, blue, green, blue, red] = sentences.stream()19                .flatMap(s -> Arrays.stream(s.split(" ")))20                .collect(Collectors.toList());21        System.out.println("allWords: " + allWords[red, blue, green, blue, red]);2223        List<Integer> evensFlat→ [2, 4, 6, 8] = nested.stream()24                .flatMap(list -> list.stream())25                .filter(n -> n % 2 == 0)26                .collect(Collectors.toList());27        System.out.println("evensFlat: " + evensFlat[2, 4, 6, 8]);
    outputflat: [1, 2, 3, 4, 5, 6, 7, 8, 9]
allWords: [red, blue, green, blue, red]
evensFlat: [2, 4, 6, 8]
flatMap Transforms each element into a stream, then flattens all streams into one.

Primitive Streams

Use specialized streams for primitives to avoid boxing overhead:

  • mapToInt, mapToDouble, mapToLong convert to primitive streams
  • IntStream, DoubleStream, LongStream provide specialized operations
rangeEnd
PrimitiveStreams.java
Replay: real traced execution (multi-file project)
import java.util.*;
import java.util.stream.*;

public class PrimitiveStreams {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        int rangeEnd = 6;

        int totalLength = words.stream()
                .mapToInt(String::length)
                .sum();
        System.out.println("totalLength: " + totalLength);

        List<Integer> squares = IntStream.range(1, rangeEnd)
                .map(n -> n * n)
                .boxed()
                .collect(Collectors.toList());
        System.out.println("squares: " + squares);

        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
        double avg = nums.stream()
                .mapToDouble(Integer::doubleValue)
                .average()
                .orElse(0.0);
        System.out.println("avg: " + avg);

        IntStream.of(3, 1, 4, 1, 5)
                .sorted()
                .distinct()
                .forEach(n -> System.out.print(n + " "));
        System.out.println();

    }
}

import java.util.*;
import java.util.stream.*;

public class PrimitiveStreams {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        int rangeEnd = 4;

        int totalLength = words.stream()
                .mapToInt(String::length)
                .sum();
        System.out.println("totalLength: " + totalLength);

        List<Integer> squares = IntStream.range(1, rangeEnd)
                .map(n -> n * n)
                .boxed()
                .collect(Collectors.toList());
        System.out.println("squares: " + squares);

        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
        double avg = nums.stream()
                .mapToDouble(Integer::doubleValue)
                .average()
                .orElse(0.0);
        System.out.println("avg: " + avg);

        IntStream.of(3, 1, 4, 1, 5)
                .sorted()
                .distinct()
                .forEach(n -> System.out.print(n + " "));
        System.out.println();

    }
}

import java.util.*;
import java.util.stream.*;

public class PrimitiveStreams {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry");
        int rangeEnd = 8;

        int totalLength = words.stream()
                .mapToInt(String::length)
                .sum();
        System.out.println("totalLength: " + totalLength);

        List<Integer> squares = IntStream.range(1, rangeEnd)
                .map(n -> n * n)
                .boxed()
                .collect(Collectors.toList());
        System.out.println("squares: " + squares);

        List<Integer> nums = Arrays.asList(1, 2, 3, 4, 5);
        double avg = nums.stream()
                .mapToDouble(Integer::doubleValue)
                .average()
                .orElse(0.0);
        System.out.println("avg: " + avg);

        IntStream.of(3, 1, 4, 1, 5)
                .sorted()
                .distinct()
                .forEach(n -> System.out.print(n + " "));
        System.out.println();

    }
}

  1. words ← [apple, banana, cherry], rangeEnd ← 6, totalLength ← 17

    4public class PrimitiveStreams {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        int rangeEnd→ 6 = 6; //@rangeEnd=6, 4, 889        int totalLength→ 17 = words.stream()10                .mapToInt(String::length)11                .sum();12        System.out.println("totalLength: " + totalLength17);1314        List<Integer> squares→ [1, 4, 9, 16, 25] = IntStream.range(1, rangeEnd6)15                .map(n -> n * n)16                .boxed()17                .collect(Collectors.toList());18        System.out.println("squares: " + squares[1, 4, 9, 16, 25]);1920        List<Integer> nums→ [1, 2, 3, 4, 5] = Arrays.asList(1, 2, 3, 4, 5);21        double avg→ 3.0 = nums.stream()22                .mapToDouble(Integer::doubleValue)23                .average()24                .orElse(0.0);25        System.out.println("avg: " + avg3.0);2627        IntStream.of(3, 1, 4, 1, 5)28                .sorted()29                .distinct()30                .forEach(n -> System.out.print(n + " "));31        System.out.println();
    outputtotalLength: 17
squares: [1, 4, 9, 16, 25]
avg: 3.0

  1. words ← [apple, banana, cherry], rangeEnd ← 4, totalLength ← 17

    4public class PrimitiveStreams {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        int rangeEnd→ 4 = 4;89        int totalLength→ 17 = words.stream()10                .mapToInt(String::length)11                .sum();12        System.out.println("totalLength: " + totalLength17);1314        List<Integer> squares→ [1, 4, 9] = IntStream.range(1, rangeEnd4)15                .map(n -> n * n)16                .boxed()17                .collect(Collectors.toList());18        System.out.println("squares: " + squares[1, 4, 9]);1920        List<Integer> nums→ [1, 2, 3, 4, 5] = Arrays.asList(1, 2, 3, 4, 5);21        double avg→ 3.0 = nums.stream()22                .mapToDouble(Integer::doubleValue)23                .average()24                .orElse(0.0);25        System.out.println("avg: " + avg3.0);2627        IntStream.of(3, 1, 4, 1, 5)28                .sorted()29                .distinct()30                .forEach(n -> System.out.print(n + " "));31        System.out.println();
    outputtotalLength: 17
squares: [1, 4, 9]
avg: 3.0

  1. words ← [apple, banana, cherry], rangeEnd ← 8, totalLength ← 17

    4public class PrimitiveStreams {5    public static void main(String[] args) {6        List<String> words→ [apple, banana, cherry] = Arrays.asList("apple", "banana", "cherry");7        int rangeEnd→ 8 = 8;89        int totalLength→ 17 = words.stream()10                .mapToInt(String::length)11                .sum();12        System.out.println("totalLength: " + totalLength17);1314        List<Integer> squares→ [1, 4, 9, 16, 25, 36, 49] = IntStream.range(1, rangeEnd8)15                .map(n -> n * n)16                .boxed()17                .collect(Collectors.toList());18        System.out.println("squares: " + squares[1, 4, 9, 16, 25, 36, 49]);1920        List<Integer> nums→ [1, 2, 3, 4, 5] = Arrays.asList(1, 2, 3, 4, 5);21        double avg→ 3.0 = nums.stream()22                .mapToDouble(Integer::doubleValue)23                .average()24                .orElse(0.0);25        System.out.println("avg: " + avg3.0);2627        IntStream.of(3, 1, 4, 1, 5)28                .sorted()29                .distinct()30                .forEach(n -> System.out.print(n + " "));31        System.out.println();
    outputtotalLength: 17
squares: [1, 4, 9, 16, 25, 36, 49]
avg: 3.0

Exercise: Practical.java

Filter a list of products by price range, then map to product names