MyTop25FavoriteJDKMethodsTest.java

import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.Test;

import java.util.*;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class MyTop25FavoriteJDKMethodsTest {
    private final List<String> fruit =
            List.of("apple", "apricot", "banana", "blueberry", "clementine");
    private final Set<String> onlyBanana =
            Set.of("banana");

    @Test
    public void with() {
        List<String> fruit =
                new ArrayList<>(List.of("apple", "apricot", "banana", "blueberry", "clementine"));

        List<String> expected =
                Arrays.asList("apple", "apricot", "banana", "blueberry", "clementine");

        Assertions.assertThat(expected).containsExactly("apple", "apricot", "banana", "blueberry", "clementine");
    }

    @Test
    public void collect() {
        List<String> uppercase = this.fruit.stream().map(String::toUpperCase).toList();

        List<String> expected =
                Arrays.asList("APPLE", "APRICOT", "BANANA", "BLUEBERRY", "CLEMENTINE");

        Assertions.assertThat(expected).containsExactly("APPLE", "APRICOT", "BANANA", "BLUEBERRY", "CLEMENTINE");
    }

    @Test
    public void of() {
        Set<String> onlyBanana = new HashSet<>(Set.of("banana"));

        Assertions.assertThat(onlyBanana).containsExactly("banana");
    }

    @Test
    public void select() {
        List<String> justBanana = this.fruit.stream().filter(onlyBanana::contains).toList();

        Assertions.assertThat(justBanana).containsExactly("banana");
    }

    @Test
    public void reject() {
        // ImmutableList<String> notBanana = this.fruit.reject(this.onlyBanana::contains);
        List<String> notBanana = this.fruit.stream().filter(Predicate.not(onlyBanana::contains)).toList();

        Assertions.assertThat(notBanana).containsExactly("apple", "apricot", "blueberry", "clementine");
    }

    @Test
    public void count() {
        long countBanana = this.fruit.stream().filter(onlyBanana::contains).count();
        long countAll = this.fruit.stream().filter(fruit::contains).count();

        Assertions.assertThat(countBanana).isEqualTo(1L);
        Assertions.assertThat(countAll).isEqualTo(5L);
    }

    @Test
    public void anySatisfy() {
        boolean anyBanana = this.fruit.stream().anyMatch(this.onlyBanana::contains);
        boolean anyEmpty = this.fruit.stream().anyMatch(String::isEmpty);

        Assertions.assertThat(anyBanana).isTrue();
        Assertions.assertThat(anyEmpty).isFalse();
    }

    @Test
    public void allSatisfy() {
        boolean allBanana = this.fruit.stream().allMatch(this.onlyBanana::contains);
        boolean allLowercase =
                this.fruit.stream().allMatch(string ->
                        IntStream.range(0, string.length()).mapToObj(string::charAt).allMatch(Character::isLowerCase));

        Assertions.assertThat(allBanana).isFalse();
        Assertions.assertThat(allLowercase).isTrue();
    }

    @Test
    public void noneSatisfy() {
        boolean noneBanana = this.fruit.stream().noneMatch(onlyBanana::contains);
        boolean noneEmpty = this.fruit.stream().noneMatch(String::isEmpty);

        Assertions.assertThat(noneBanana).isFalse();
        Assertions.assertThat(noneEmpty).isTrue();
    }

    @Test
    public void groupBy() {
        Map<Character, List<String>> multimap =
                this.fruit.stream().collect(
                        Collectors.collectingAndThen(
                                Collectors.groupingBy(fruit -> fruit.charAt(0)),
                                Collections::unmodifiableMap));

        Assertions.assertThat(multimap.get('a')).containsExactly("apple", "apricot");
        Assertions.assertThat(multimap.get('b')).containsExactly("banana", "blueberry");
        Assertions.assertThat(multimap.get('c')).containsExactly("clementine");
    }

    @Test
    public void countBy() {

        Map<Character, Long> firstLetterCounts =
                this.fruit.stream().collect(
                        Collectors.collectingAndThen(
                                Collectors.groupingBy(fruit -> fruit.charAt(0), Collectors.counting()),
                                Collections::unmodifiableMap));

        Assertions.assertThat(firstLetterCounts.get('a')).isEqualTo(2L);
        Assertions.assertThat(firstLetterCounts.get('b')).isEqualTo(2L);
        Assertions.assertThat(firstLetterCounts.get('c')).isEqualTo(1L);
    }

    @Test
    public void makeString() {
        String fruitString = this.fruit.stream().collect(Collectors.joining(",", "(", ")"));

        Assertions.assertThat(fruitString).isEqualTo("(apple,apricot,banana,blueberry,clementine)");
    }

    @Test
    public void toImmutable() {
        List<String> mutableFruit =
                new ArrayList<>(List.of("apple", "apricot", "banana", "blueberry", "clementine"));

        List<String> immutableFruit = Collections.unmodifiableList(mutableFruit);

        Assertions.assertThat(immutableFruit).containsExactly("apple", "apricot", "banana", "blueberry", "clementine");
    }

    @Test
    public void asLazy() {

        Iterable<String> fruitIterable = this.fruit::iterator;
        Stream<String> stream = StreamSupport.stream(fruit.spliterator(), false);

        Assertions.assertThat(stream.count()).isEqualTo(5L);
    }

    @Test
    public void containsBy() {

        boolean hasApple = this.fruit.stream().map(String::toUpperCase).anyMatch("APPLE"::equals);
        boolean hasTomato = this.fruit.stream().map(String::toUpperCase).anyMatch("TOMATO"::equals);

        Assertions.assertThat(hasApple).isTrue();
        Assertions.assertThat(hasTomato).isFalse();
    }

    @Test
    public void detectWith() {

        String banana = this.fruit.stream().filter(s -> s.startsWith("b")).findAny().orElse(null);
        String none = this.fruit.stream().filter(s -> s.startsWith("d")).findAny().orElse(null);

        Assertions.assertThat(banana).isEqualTo("banana");
        Assertions.assertThat(none).isNull();
    }

    @Test
    public void detectWithIfNone() {
        String banana = this.fruit.stream().filter(s -> s.startsWith("b")).findAny().orElseGet(() -> "apple");
        String stillBanana = this.fruit.stream().filter(s -> s.startsWith("b")).findAny().orElseGet(() -> "banana");

        Assertions.assertThat(banana).isEqualTo("banana");
        Assertions.assertThat(stillBanana).isEqualTo("banana");
    }

    @Test
    public void injectInto() {
        String mixedFruitString = this.fruit.stream().collect(Collectors.joining());

        Assertions.assertThat(mixedFruitString).isEqualTo("appleapricotbananablueberryclementine");
    }

    @Test
    public void partition() {

        Map<Boolean, List<String>> partitionFruit =
                this.fruit.stream().collect(
                        Collectors.collectingAndThen(
                                Collectors.partitioningBy(fruit -> fruit.length() > 6),
                                map -> Map.of(true, Collections.unmodifiableList(map.get(true)),
                                        false, Collections.unmodifiableList(map.get(false)))
                        ));

        List<String> selected = partitionFruit.get(true);
        List<String> rejected = partitionFruit.get(false);

        Assertions.assertThat(selected).containsExactly("apricot", "blueberry", "clementine");
        Assertions.assertThat(rejected).containsExactly("apple", "banana");
    }

    @Test
    public void chunk() {

        record ChunkIndexes(int fromIndex, int toIndex) {

            <T> List<T> applyTo(List<T> list) {
                return list.subList(fromIndex, toIndex);
            }
        }

        record Indexes(int listSize, int chunkSize) {

            List<ChunkIndexes> chunkIndexes() {
                return IntStream.range(0, listSize)
                        .filter(index -> index % chunkSize == 0)
                        .mapToObj(index -> new ChunkIndexes(index, Integer.min(listSize, index + chunkSize)))
                        .collect(Collectors.toList());
            }
        }

        List<List<String>> chunkFruit =
                new Indexes(this.fruit.size(), 2)
                        .chunkIndexes().stream()
                        .map(chunkIndexes -> chunkIndexes.applyTo(this.fruit))
                        .collect(Collectors.toList());

        Assertions.assertThat(chunkFruit.size()).isEqualTo(3);
        Assertions.assertThat(chunkFruit.get(0)).containsExactly("apple", "apricot");
        Assertions.assertThat(chunkFruit.get(2)).containsExactly("clementine");
    }

    @Test
    public void sumByInt() {
        Map<Character, Integer> sumLengthsByFirstCharacter =
                this.fruit.stream()
                        .collect(
                                Collectors.collectingAndThen(
                                        Collectors.groupingBy(
                                                fruit -> fruit.charAt(0),
                                                Collectors.summingInt(String::length)),
                                        Collections::unmodifiableMap
                                ));

        Assertions.assertThat(sumLengthsByFirstCharacter.get('a')).isEqualTo(12);
        Assertions.assertThat(sumLengthsByFirstCharacter.get('b')).isEqualTo(15);
        Assertions.assertThat(sumLengthsByFirstCharacter.get('c')).isEqualTo(10);
    }

    @Test
    public void collectInt() {

        List<Integer> lengths = this.fruit.stream().map(String::length).collect(Collectors.toList());

        Assertions.assertThat(lengths).containsExactly(5, 7, 6, 9, 10);
    }

    @Test
    public void flatCollectChar() {

        Map<Character, Long> charCounts =
                this.fruit.stream()
                        .flatMap(word -> IntStream.range(0, word.length()).mapToObj(word::charAt))
                        .collect(Collectors.groupingBy(
                                Function.identity(), Collectors.counting()
                        ));

        Assertions.assertThat(charCounts.get('a')).isEqualTo(5);
        Assertions.assertThat(charCounts.get('b')).isEqualTo(3);
        Assertions.assertThat(charCounts.get('c')).isEqualTo(2);
    }

    @Test
    public void asParallel() {

        List<String> onlyBananaList =
                this.fruit.parallelStream()
                        .filter(this.onlyBanana::contains)
                        .collect(Collectors.toList());

        Set<String> onlyBananaSet =
                this.fruit.parallelStream()
                        .filter(this.onlyBanana::contains)
                        .collect(Collectors.toSet());

        Assertions.assertThat(onlyBananaList).containsExactly("banana");
        Assertions.assertThat(onlyBananaSet).containsExactly("banana");
    }

    @Test
    public void distinct() {

        List<String> duplicateFruit = List.of("apple", "apple", "banana", "banana");

        List<String> distinctFruit = duplicateFruit.stream().distinct().collect(Collectors.toList());

        Assertions.assertThat(distinctFruit).containsExactly("apple", "banana");
    }

}