Lec 09 - InfiniteList and Stream

Eager List vs. Infinite List

• EagerList: Stores actual values directly in fields (T head, EagerList<T> tail)

• InfiniteList: Stores producers of values (Producer<T> head, Producer<InfiniteList<T>> tail)

Always use this recursive thinking — A list is made up of its head element and the rest ("tail") when dealing with Eager List and Infinite List.

Method Implementations

1

head()

EagerList

public T head() {
  return this.head;
}

InfiniteList

Difference: EagerList directly returns the stored value, while InfiniteList produces the value on demand and handles null by recursively checking the tail.

2

tail()

Purpose: Returns the list without its first element.

EagerList

public EagerList<T> tail() {
  return this.tail;
}

InfiniteList

Difference: EagerList directly returns the stored tail list, while InfiniteList produces the tail only when needed and handles null values.

3

get(int n)

Purpose: Retrieves the element at position n in the list.

EagerList

public T get(int n) {
  if (n == 0) {
    return this.head();
  }
  return this.tail().get(n - 1);
}

InfiniteList

Difference: Both implementations use the same recursive approach, but InfiniteList's implementation inherently evaluates lazily due to its structure.

When n ≠ 0, due to the implementation of tail(), the InfiniteList will evaluate the elements from the start all the way until getting the element you want! This may be useful in stack and heap tracing.

4

generate()

Purpose: Creates a list with repeated values.

EagerList

// generate(1, 4) -> 1 1 1 1
// generate(4, 1) -> 4
public static <T> EagerList<T> generate(T t, int size) {
  if (size == 0) {
    return empty();
  }
  return new EagerList<>(t, generate(t, size - 1));
}

InfiniteList

Difference: EagerList creates a fixed-size list with a repeated value, while InfiniteList creates a potentially infinite list using a producer function (so there is no need for size parameter)

5

iterate()

Purpose: Creates a sequence by repeatedly applying a transformation.

EagerList

  // iterate(1, x -> x <= 10, x -> x + 1) gives us 1 2 3 4 5 6 7 8 9 10
  public static <T> EagerList<T> iterate(
      T init, BooleanCondition<? super T> cond, Transformer<? super T, ? extends T> op) {
    if (!cond.test(init)) {
      return empty();
    }
    return new EagerList<>(init, iterate(op.transform(init), cond, op));
  }

InfiniteList

Difference: EagerList requires a condition to terminate the iteration, while InfiniteList can continue indefinitely, creating a potentially infinite sequence.

6

map()

Purpose: Transforms each element in the list using a provided function.

EagerList

// (1 2 3 4).map(x -> x * x) gives us (1, 4, 9, 16)
public <R> EagerList<R> map(Transformer<? super T, ? extends R> mapper) {
  return new EagerList<>(mapper.transform(this.head()), this.tail.map(mapper));
}

InfiniteList

Difference: EagerList immediately applies the transformation to each element, while InfiniteList creates a new list with transformation functions that will execute only when the values are needed.

7

filter()

Purpose: Creates a new list containing only elements that satisfy a condition.

EagerList

// (1 2 3 4).filter(x -> x % 2 == 0) gives us (2, 4)
public EagerList<T> filter(BooleanCondition<? super T> cond) {
  if (cond.test(this.head())) {
    return new EagerList<>(this.head(), this.tail().filter(cond));
  }
  return this.tail.filter(cond);
}

InfiniteList

Difference: EagerList immediately evaluates conditions and creates a new list with only matching elements. InfiniteList creates a producer that will check the condition only when the element is accessed, returning null for elements that don't match.

Tips

In summary, here are some tips

1. A lambda can only be passed to a method if the method's parameter is a Functional Interface

2. The lambda passed in defines how the functional interface works!

3. For the InifiniteList, the element will only be evaluated when we call either get() (indirectly calling head()) or head() directly.

Revisit Lazy Evaluation

Lazy evaluation means we can delay a computation using the Producer functional interface. So, instead of doing compute() which is immediately evaluated when executed, we replace it with a Producer () -> compute(), which "stores" the computation in an instance of Producer, and we only call it when we invoke the produce method. (In Infinite List, invoking the produce method is done by calling head() directly or indirectly).

Under the Hood

For the Infinite List, what on earth happen if we try to invoke the following code, where evens is an Infinite List with 0, 2, 4, 6, 8, ....

evens.map(x -> x + 1).map(x -> x * 2).head(); // 2

First, let's rewrite this statement by adding some intermediate variables

InfiniteList<Integer> evens = InfiniteList.iterate(0, x -> x + 2); // 0, 2, 4, 6, ...
InfiniteList<Integer> odds = evens.map(x -> x + 1); // 1, 3, 5, ...
InfiniteList<Integer> altEvens = odds.map(x -> x * 2); // 2, 6, 10, .. 
altEvens.head();

First, when we create an evens,

InfiniteList<Integer> evens = InfiniteList.iterate(0, x -> x + 2); // 0, 2, 4, 6, ...

The heap should look as follow,

evens is an object which has two fields, head and tail, and each points to an instance of the Producer functional interface (a.k.a, a lambda expression shown in the figure). As we have seen before,

a lambda expression is essentially syntactic sugar for writing an anonymous class that implements a functional interface.

so, here inside these two lambdas, it will follow the exact rules of variable capture, which are

the local class (including the anonymous class) will capture the following variables

1. The local variables of the method where the local class comes from (including only the arguments that the lambda uses, see more in Diagnostic Quiz Q13)

2. The instance that invokes the method where the local class comes from. (See more in Rec 05)

So, the two lambdas capture the variable init. The tail additionally captures the variable next, which itself is an instance of Transformer<T, T>.

---

Similarly, you will get the final graph shown like below

For more information, please see from the lecture notes.

1. When you call infiList1 = InfiniteList.operation, the head and tail fields in the infiList1 point to two anonymous classes implemented in lambdas which capture the variable appeared in that lambda.

2. When you call infiList2 = infiList1.opeartion, the head and tail fields in teh infiList2 point to two anonymouse classes also, but with another this field in each of them, which points to infiList1.

Streams

Our Infinite List has its counterpart in the Java implementation, which is called Stream, but with more functionalities. All the methods introduced below are called stream operations!

Building a Stream

We can build a stream by using

1

of

We can use the static factory method of (e.g., Stream.of(1, 2, 3)).

Method Declaration

t is the element of the Stream.

static <T> Stream<T> of(T t)

Example

// 1. Using static factory method Stream.of()
Stream<Integer> streamOf = Stream.of(1, 2, 3, 4, 5);
streamOf.forEach(System.out::println);
// Expected output:
// 1
// 2
// 3
// 4
// 5

2

generate() and iterate()

We can use the generate and iterate methods (similar to our InfiniteList)

Method Declaration

generate()

Supplier is the same as Producer in CS2030S.

static <T> Stream<T> generate(Supplier<? extends T> s)

iterate()

Example

generate()

// 2. Using Stream.generate() - creates an infinite stream
Stream<Integer> streamGenerate = Stream.generate(() -> 7).limit(5);
streamGenerate.forEach(i -> System.out.print(i + " "));
// Expected output: 7 7 7 7 7

Iterate()

3

Arrays::stream

We can convert an array into a Stream using Arrays::stream

// 4. Converting an array to a Stream using Arrays.stream()
Integer[] array = {6, 7, 8, 9, 10};
Stream<Integer> streamFromArray = Arrays.stream(array);
streamFromArray.forEach(System.out::println);
// Expected output:
// 6
// 7
// 8
// 9
// 10

4

List::stream

We can convert a List instance (or any Collection instance) into a Stream using List::stream

// 5. Converting a Collection (List) to a Stream using List.stream()
List<String> list = List.of("apple", "banana", "cherry", "date");
Stream<String> streamFromList = list.stream();
streamFromList.forEach(System.out::println);
// Expected output:
// apple
// banana
// cherry
// date

Terminal Operations

A terminal operation is an operation on the stream that triggers the evaluation of the stream. A typical way of writing code that operates on streams is to chain a series of intermediate operations together, ending with a terminal operation.

1

forEach

The forEach method is a terminal operation that takes in a stream and applies a lambda expression to each element.

The lambda expression to apply does not return any value. Java provides the Consumer<T> functional interface for this. We have already seen pretty much examples from Building a Stream.

Method Declaration

action is a Consumer, which is equivalent to Consumer in CS2030S.

void forEach(Consumer<? super T> action)

Example

// Example of forEach terminal operation in Stream
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
System.out.print("Processing each element: ");
numbers.stream()
       .forEach(num -> System.out.print(num + " "));
// Expected output: Processing each element: 1 2 3 4 5

2

count()

The count() method in Java Streams is a terminal operation that returns the number of elements in the stream.

long count = Stream.of("apple", "banana", "cherry").count();
System.out.println(count); // Output: 3

count processes the entire stream, so calling it on an infinite stream will cause an infinite loop.

3

reduce()

The reduce operation applies a binary function (or a.k.a, a Combiner in CS2030S) to each element in the stream to reduce them to a single result.

Method Declaration

The BinaryOperator is equivalent to Combiner in CS2030S.

T reduce(T identity, BinaryOperator<T> accumulator)

Example

// reduce example
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
int sum = numbers.stream()
                .reduce(0, (a, b) -> a + b);
System.out.println("Sum: " + sum);
// Expected output: Sum: 15

Here, 0 is called the identity value, (a,b) -> a + b is called an accumulation function. This process is equivalent to the following pseudocode:

result = identity
for each element in the stream
     result = accumulator.apply(result, element)
return result

4

noneMatch()

The noneMatch operation returns true if no elements in the stream match the given predicate, short-circuiting (stopping early) if any matching element is found.

Method Declaration

Predicate is equivalent to BooleanCondition in CS2030S.

boolean noneMatch(Predicate<? super T> predicate)

Example

// noneMatch example
List<Integer> numbers = List.of(1, 3, 5, 7, 9);
boolean hasNoEvens = numbers.stream()
                           .noneMatch(n -> n % 2 == 0);
System.out.println("No even numbers: " + hasNoEvens);
// Expected output: No even numbers: true

5

allMatch()

The allMatch operation returns true if all elements in the stream match the given predicate, short-circuiting if any non-matching element is found.

Method Declaration

Predicate is equivalent to BooleanCondition in CS2030S.

boolean allMatch(Predicate<? super T> predicate)

Example

// allMatch example
List<Integer> numbers = List.of(1, 3, 5, 7, 9);
boolean allPositive = numbers.stream()
                            .allMatch(n -> n > 0);
System.out.println("All positive numbers: " + allPositive);
// Expected output: All positive numbers: true

6

anyMatch()

The anyMatch operation returns true if at least one element in the stream matches the given predicate, short-circuiting once a matching element is found.

Method Declaration

Predicate is equivalent to BooleanCondition in CS2030S.

boolean anyMatch(Predicate<? super T> predicate)

Example

// anyMatch example
List<Integer> numbers = List.of(1, 3, 5, 7, 9);
boolean hasDigitGreaterThan5 = numbers.stream()
                                     .anyMatch(n -> n > 5);
System.out.println("Has number greater than 5: " + hasDigitGreaterThan5);
// Expected output: Has number greater than 5: true

Intermediate Stream Operations

An intermediate operation on stream returns another Stream. Intermediate operations are lazy and do not cause the stream to be evaluated.

1

map()

The map operation transforms each element in the stream by applying a function to it, producing a new stream of the transformed elements with a one-to-one relationship.

Method Declaration

Function is equivalent to Transformer<T,R> in CS2030S.

<R> Stream<R> map(Function<? super T,? extends R> mapper)

Example

// map example
List<String> words = List.of("Java", "Stream", "API");
words.stream()
     .map(String::length)
     .forEach(length -> System.out.print(length + " "));
// Expected output: 4 6 3

2

flatMap()

The flatMap operation transforms each element into a stream and then flattens all resulting streams into a single stream, useful for working with nested collections or when one element should produce multiple output elements

Method Declaration

Function is equivalent to Transformer<T,R> in CS2030S.

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

Example

// flatMap example
List<List<Integer>> nestedLists = List.of(
    List.of(1, 2), 
    List.of(3, 4, 5), 
    List.of(6)
);
nestedLists.stream()
           .flatMap(Collection::stream)
           .forEach(num -> System.out.print(num + " "));
// Expected output: 1 2 3 4 5 6

flatMap takes each element in the stream (each inner list) and transforms it into a new stream of its own elements (e.g. a stream of 1,2, a stream of 3, 4, 5 and a stream of 6) . Then, it "flattens" all these streams into one single stream.

Why Collection not List here? It is because Collection is a broader concept that includes List. It’s a way to write flexible code that could work with other collection types (like Set) if needed. Here, since the inner elements are Lists, it works perfectly.

3

filter()

The filter operation selects elements from the stream that satisfy a given predicate (boolean condition), creating a new stream that contains only the elements that passed the test.

What if no element passes the predicate?

Method Declaration

Predicate is equivalent to BooleanCondition in CS2030S.

Stream<T> filter(Predicate<? super T> predicate)

Example

// filter example
List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
numbers.stream()
       .filter(n -> n % 2 == 0)  // Keep only even numbers
       .forEach(n -> System.out.print(n + " "));
// Expected output: 2 4 6 8 10

4

sorted()

The sorted operation arranges elements according to natural order or a provided comparator, requiring the entire stream to be processed before producing any results.

// sorted example
List<Integer> numbers = List.of(5, 3, 8, 1, 4);
numbers.stream()
       .sorted()
       .forEach(n -> System.out.print(n + " "));
// Expected output: 1 3 4 5 8

5

distinct()

The distinct operation filters out duplicate elements based on their equals() method, returning a stream with only unique elements.

// distinct example
List<Integer> duplicates = List.of(1, 2, 2, 3, 3, 3, 4, 4, 4, 4);
duplicates.stream()
          .distinct()
          .forEach(n -> System.out.print(n + " "));
// Expected output: 1 2 3 4

Both sorted() and distinct() operations are stateful (they maintain internal state about previously seen elements) and bounded (they need to process all elements before producing results, a.k.a, they should only be called on a finite stream), which impacts performance especially with large datasets.

6

limit()

The limit operation restricts the stream to process only a maximum number of elements, which can improve performance for large or infinite streams.

// limit example
List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
numbers.stream()
       .limit(5)
       .forEach(n -> System.out.print(n + " "));
// Expected output: 1 2 3 4 5

7

takeWhile()

The takeWhile operation (introduced in Java 9) takes elements from the stream as long as the predicate returns true, stopping at the first element that fails the condition.

Method Declaration

Predicate is equivalent to BooleanCondition in CS2030S.

default Stream<T> takeWhile(Predicate<? super T> predicate)

Example

// takeWhile example (Java 9+)
List<Integer> numbers2 = List.of(2, 4, 6, 7, 8, 10);
numbers2.stream()
        .takeWhile(n -> n % 2 == 0)
        .forEach(n -> System.out.print(n + " "));
// Expected output: 2 4 6

limit() and takeWhile() are intermediate opeartions that convert from infinite stream to finite stream. (Although finite, but still lazy evaluated)

8

peek()

The peek operation creates a "fork" in the stream pipeline, allowing us to perform side effects (like debugging) without modifying the elements flowing through the stream. It takes a Consumer function that can view or process each element while letting the original elements continue unchanged through the pipeline.

Method Declaration

Consumer is equivalent to Consumer in CS2030S.

Stream<T> peek(Consumer<? super T> action)

Example

// peek example
List<String> names = List.of("Alice", "Bob", "Charlie");
names.stream()
     .peek(name -> System.out.print("Processing: " + name + " -> "))
     .map(String::toUpperCase)
     .forEach(name -> System.out.println(name));
// Expected output:
// Processing: Alice -> ALICE
// Processing: Bob -> BOB
// Processing: Charlie -> CHARLIE

Consumed Once

One of the greatest limitations of Stream, which does not apply to our InfiniteList, is that a stream can only be operated once.

Stream<Integer> s = Stream.of(1,2,3);
s.count();
s.count(); // <- error

Specialized Stream

Java provides specialized streams (IntStream, LongStream, and DoubleStream) to work efficiently with primitive types, these streams have the following advantages

1

Avoid the boxing/unboxing overhead of wrapper classes

// IntStream example - Avoiding boxing/unboxing overhead
List<Integer> boxedInts = List.of(1, 2, 3, 4, 5);

// Using specialized methods after converting from regular stream
int sum = boxedInts.stream()
                  .mapToInt(Integer::intValue)  // Convert to IntStream
                  .sum();  // Specialized IntStream method
System.out.println("Sum: " + sum);
// Expected output: Sum: 15

This can be simplified to as follows:

// IntStream example - Creating and using IntStream
IntStream intStream = IntStream.range(1, 6);  // 1 to 5
int sum = intStream.sum();
System.out.println("Sum: " + sum);
// Expected output: Sum: 15

2

Offer specialized methods like sum() and average() for numerical operations

// DoubleStream example - Numeric operations
double[] values = {1.1, 2.2, 3.3, 4.4, 5.5};
DoubleStream doubleStream = Arrays.stream(values);
DoubleStream.of(1.1, 2.2, 3.3, 4.4, 5.5)
           .average()
           .ifPresent(avg -> System.out.println("Average: " + avg));
// Expected output: Average: 3.3

3

Can be created through factory methods like range(), rangeClosed(), or by converting from regular streams using mapToInt(), mapToLong(), or mapToDouble()

// LongStream example - Using factory methods
LongStream longRange = LongStream.range(1L, 6L);  // Creates 1 to 5
LongStream longRangeClosed = LongStream.rangeClosed(1L, 5L);  // Creates 1 to 5 (same result)
System.out.println("Count from range: " + longRange.count());
System.out.println("Max from rangeClosed: " + longRangeClosed.max().orElse(0));
// Expected output: 
// Count from range: 5
// Max from rangeClosed: 5

These specialized streams maintain the same pipeline pattern as regular streams while providing better performance for numeric computations.

Elegance of Stream

This can be vividly shown by using an example to count the first 500 primes. Initially, our code looks like,

void fiveHundredPrime() {
  int count = 0;
  int i = 2;
  while (count < 500) {
    if (isPrime(i)) {
      System.out.println(i);
      count++;
    }
    i++;
  }
}

By using Java Streams, this can be simplified to

IntStream.iterate(2, x -> x+1)
    .filter(x -> isPrime(x))
    .limit(500)
    .forEach(System.out::println);