Script JBang montrant des exemples de création de tableau de fréquences avec boucle for et streams en Java

FrequenciesMap.java

/// usr/bin/env jbang "$0" "$@" ; exit $?
//DEPS org.assertj:assertj-core:3.24.2
// A exécuter avec JBang : jbang FrequenciesMap.java

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import static java.lang.System.*;
import static java.util.stream.Collectors.summingInt;
import static org.assertj.core.api.Assertions.assertThat;

public class FrequenciesMap {

  public static void main(String... args) {
    out.println("Frequencies Map Examples\n");
    List<String> daysOfWeek =
        List.of(
            "Friday",
            "Thursday",
            "Thursday",
            "Saturday",
            "Thursday",
            "Thursday",
            "Monday",
            "Saturday",
            "Friday",
            "Saturday");
    Map<String, Integer> expectedFrequenciesMap1 =
        Map.of("Monday", 1, "Thursday", 4, "Friday", 2, "Saturday", 3);
    Map<String, Long> expectedFrequenciesMap2 =
            Map.of("Monday", 1L, "Thursday", 4L, "Friday", 2L, "Saturday", 3L);

    out.println("\nTesting the creation of a frequencies map with a for loop");
    Map<String, Integer> frequenciesMapOldSchool = createFrequenciesMapOldSchool(daysOfWeek);
    assertThat(frequenciesMapOldSchool).isNotEmpty().containsExactlyInAnyOrderEntriesOf(expectedFrequenciesMap1);
    frequenciesMapOldSchool.entrySet().iterator().forEachRemaining(out::println);

    out.println("\nTesting the creation of a frequencies map with a streams and the counting method");
    Map<String, Long> frequenciesMapWithStreams = createFrequenciesMapWithStreams(daysOfWeek);
    assertThat(frequenciesMapWithStreams).isNotEmpty().containsExactlyInAnyOrderEntriesOf(expectedFrequenciesMap2);
    frequenciesMapWithStreams.entrySet().iterator().forEachRemaining(out::println);

    out.println("\nTesting the creation of a frequencies map with a streams and summingInt");
    Map<String, Integer> frequenciesMapWithStreamsAndInts =
        createFrequenciesMapWithStreamsAndInts(daysOfWeek);
    assertThat(frequenciesMapWithStreamsAndInts).isNotEmpty().containsExactlyInAnyOrderEntriesOf(expectedFrequenciesMap1);
    frequenciesMapWithStreamsAndInts.entrySet().iterator().forEachRemaining(out::println);
  }

  private static <T> Map<T, Integer> createFrequenciesMapOldSchool(List<T> elements) {
    Map<T, Integer> frequencies = new HashMap<>();
    int previousCount;
    for (T element : elements) {
      previousCount = frequencies.getOrDefault(element, 0);
      frequencies.put(element, previousCount + 1);
    }

    return frequencies;
  }

  private static <T> Map<T, Long> createFrequenciesMapWithStreams(List<T> elements) {
    return elements.stream()
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
  }

  private static <T> Map<T, Integer> createFrequenciesMapWithStreamsAndInts(List<T> elements) {
    return elements.stream()
        .collect(Collectors.groupingBy(Function.identity(), summingInt(element -> 1)));
  }
}