Item Give preference to functions without side effects in streams

Introduction to using streams:

• New users may find it difficult to express calculations in stream pipelines.
• Streams are based on functional programming, offering expressiveness, speed and parallelization.

Structuring of the calculation:

• Structure calculations as sequences of transformations using pure functions.
• Pure functions depend only on their inputs and do not change state.

Side effects:

• Avoid side effects in functions passed to stream operations.
• Improper use of forEach that changes external state is a "bad smell".

Example 1: Code with side effects

Map<String, Long> freq = new HashMap<>();
try (Stream<String> words = new Scanner(file).tokens()) {
    words.forEach(word -> {
        freq.merge(word.toLowerCase(), 1L, Long::sum);
    });
}

Problem: This code uses forEach to modify the external state (freq). It is iterative and does not take advantage of streams.

Example 2: Code without side effects

Map<String, Long> freq;
try (Stream<String> words = new Scanner(file).tokens()) {
    freq = words.collect(Collectors.groupingBy(String::toLowerCase, Collectors.counting()));
}

Solution: Uses the Collectors.groupingBy collector to create the frequency table without changing the external state. Shorter, clearer and more efficient.

Appropriation of the streams API:

• Code that imitates iterative loops does not take advantage of streams.
• Use collectors for more efficient and readable operations.

Collectors:

• Simplify collecting results into collections such as lists and sets.
• Collectors.toList(), Collectors.toSet(), Collectors.toCollection(collectionFactory).

Example 3: Extracting a list of the ten most frequent words

List<String> topTen = freq.entrySet().stream()
    .sorted(Map.Entry.<String, Long>comparingByValue().reversed())
    .limit(10)
    .map(Map.Entry::getKey)
    .collect(Collectors.toList());

Explanation:

• Orders the frequency map entries in descending order of value.
• Limits the stream to 10 words.
• Collects the most frequent words in a list.

Complexity of the Collectors API:

• API has 39 methods, but many are for advanced use.
• Collectors can be used to create maps (toMap, groupingBy).

Maps and collection strategies:

• toMap(keyMapper, valueMapper) for unique key-values.
• Strategies for dealing with key conflicts using the merge function.
• groupingBy to group elements into categories based on classifier functions.

Example 4: Using toMap with merge function

Map<String, Long> freq;
try (Stream<String> words = new Scanner(file).tokens()) {
    freq = words.collect(Collectors.toMap(
        String::toLowerCase, 
        word -> 1L, 
        Long::sum
    ));
}

Explanation:

• toMap maps words to their frequencies.
• Merge function (Long::sum) deals with key conflicts by summing the frequencies.

Example 5: Grouping albums by artist and finding the best-selling album

Map<Artist, Album> topAlbums = albums.stream()
    .collect(Collectors.toMap(
        Album::getArtist,
        Function.identity(),
        BinaryOperator.maxBy(Comparator.comparing(Album::sales))
    ));

Explanation:

• toMap maps artists to their best-selling albums.
• BinaryOperator.maxBy determines the best-selling album for each artist.

String Collection:
Collectors.joining to concatenate strings with optional delimiters.

Example 6: Concatenating strings with delimiter

String result = Stream.of("came", "saw", "conquered")
    .collect(Collectors.joining(", ", "[", "]"));

Explanation:

• Collectors.joining concatenates strings with a comma as delimiter, prefix and suffix.
• Result: [came, saw, conquered].

Conclusion:

• Essence of streams is in functions without side effects.
• forEach should only be used to report results.
• Knowledge about collectors is essential for effective use of streams.

The above is the detailed content of Item Give preference to functions without side effects in streams. For more information, please follow other related articles on the PHP Chinese website!