SimpleTimer.java

package chapter7;

import java.util.function.Supplier;

public abstract class SimpleTimer {

    public record Result<T>(long duration_ms, T result) {}

    public static <T> chapter7.SimpleTimer.Result<T> timeIt(Supplier<T> supplier) {
        long start = System.currentTimeMillis();
        T result = supplier.get();
        long stop = System.currentTimeMillis();
        return new Result<T>(stop - start, result);
    }
}

BeingLazy_InfiniteCollections.java

package chapter7;

import org.junit.jupiter.api.Test;

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toList;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class BeingLazy_InfiniteCollections {

    // If CPU cycles are of no importance...
    // "a desparate attempt", p.133

    public static boolean isPrimeVeryGorilla(final int number) {
        return number > 1 &&
                IntStream.rangeClosed(2, (int) Math.sqrt(number))
                        .noneMatch(divisor -> number % divisor == 0);
    }

    // This doesn't work as it causes an infinite recursion
    // "a desparate attempt", p.134, but with different method & parameter names

    public static List<Integer> primesUpwardsFrom_notworking(final int number) {
        if (isPrimeVeryGorilla(number)) {
            List<Integer> morePrimes = primesUpwardsFrom_notworking(number + 1);
            morePrimes.add(0, number);
            return morePrimes;
        } else {
            return primesUpwardsFrom_notworking(number + 1);
        }
    }

    // "lazy/fpij/Primes.java", p.135, but with different method & parameter names

    private static int firstPrimeAfter(final int number) {
        if (isPrimeVeryGorilla(number + 1)) {
            return number + 1;
        } else {
            return firstPrimeAfter(number + 1);
        }
    }

    // "lazy/fpij/Primes.java", p.135, but with different method & parameter names

    private static List<Integer> primesUpwardsFrom(final int fromNumber, final int count) {
        return Stream.iterate(firstPrimeAfter(fromNumber - 1), BeingLazy_InfiniteCollections::firstPrimeAfter)
                .limit(count)
                .collect(toList());
    }

    // Testing primesUpwardsFrom()
    // https://en.wikipedia.org/wiki/List_of_prime_numbers
    // https://oeis.org/A000040

    @Test
    public void generatePrimes() {
        final var shall = List.of(101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
                179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281);
        final List<Integer> primesAfter100 = primesUpwardsFrom(100, shall.size());
        final String txt = primesAfter100.stream().map(it -> Integer.toString(it)).collect(Collectors.joining(",\n"));
        System.out.println(txt);
        assertEquals(shall, primesAfter100);
    }

    // Testing primesUpwardsFrom()
    // Similar to "lazy/fpij/Primes.java" on p.136

    @Test
    public void runBookPrimes() {
        List<Integer> l1 = primesUpwardsFrom(1, 10);
        List<Integer> l2 = primesUpwardsFrom(100, 5);
        assertEquals(List.of(2, 3, 5, 7, 11, 13, 17, 19, 23, 29), l1);
        assertEquals(List.of(101, 103, 107, 109, 113), l2);
        System.out.println("10 primes from 1: " + l1);
        System.out.println("5 primes from 100: " + l2);
    }


    // It's quite slow!

    @Test
    void runBookPrimesWithTimer() {
        final int limit = 1_000_000;
        // not an actual test, just printout
        final SimpleTimer.Result<List<Integer>> stRes =
                SimpleTimer.timeIt(
                        () -> primesUpwardsFrom(2, limit)
                );
        final List<Integer> result = stRes.result();
        final String range = (result.isEmpty()) ? "" : "in range [" + result.get(0) + "," + result.get(result.size() - 1) + "] ";
        System.out.println("Using book code: finding " + result.size() + " primes " + range + "took " + stRes.duration_ms() + " ms");
    }

}