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");
}
}
