Iterator

const MINUTES = [14, 32, 8, 21, 40, 9, 12, 18, 25, 7, 30, 11];   // T-12 (newest) ... T-1 (oldest)

interface Trip { tripId: string; month: string; minutes: number; }

// Stands in for the trips service: returns one page at a time, newest first, and counts calls.
class TripApi {
  readonly trips: Trip[] = MINUTES.map((m, i) => ({ tripId: `T-${12 - i}`, month: i < 4 ? "October" : "September", minutes: m }));
  pagesFetched = 0;
  page(n: number, size: number): Trip[] { this.pagesFetched++; return this.trips.slice(n * size, (n + 1) * size); }
}

// The iterable collection: callers loop over trips; pages are fetched only when the loop needs them.
class TripHistory implements Iterable<Trip> {
  constructor(private readonly api: TripApi, private readonly pageSize = 3) {}
  *[Symbol.iterator](): Iterator<Trip> {
    for (let n = 0; ; n++) {
      const page = this.api.page(n, this.pageSize);
      if (!page.length) return;
      yield* page;
      if (page.length < this.pageSize) return;
    }
  }
}

let api = new TripApi();
const october: Trip[] = [];
for (const trip of new TripHistory(api)) {   // newest first, so stop at the first older trip
  if (trip.month !== "October") break;
  october.push(trip);
}
console.log("October trips: " + october.map((t) => `${t.tripId} (${t.minutes} min)`).join(", "));
console.log(`October total: ${october.reduce((s, t) => s + t.minutes, 0)} min | pages fetched: ${api.pagesFetched} of 4`);

api = new TripApi();
let firstLong: Trip | undefined;
for (const t of new TripHistory(api)) if (t.minutes > 30) { firstLong = t; break; }
console.log(`first trip over 30 minutes: ${firstLong!.tripId} | pages fetched: ${api.pagesFetched}`);

api = new TripApi();
let count = 0;
for (const _ of new TripHistory(api)) { void _; count++; }
console.log(`all trips: ${count} | page requests: ${api.pagesFetched} (the last comes back empty)`);

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

public class Main {
    static final int[] MINUTES = {14, 32, 8, 21, 40, 9, 12, 18, 25, 7, 30, 11};   // T-12 (newest) ... T-1 (oldest)

    record Trip(String tripId, String month, int minutes) {}

    // Stands in for the trips service: returns one page at a time, newest first, and counts calls.
    static class TripApi {
        final List<Trip> trips = new ArrayList<>();
        int pagesFetched;
        TripApi() { for (int i = 0; i < MINUTES.length; i++) trips.add(new Trip("T-" + (12 - i), i < 4 ? "October" : "September", MINUTES[i])); }
        List<Trip> page(int n, int size) {
            pagesFetched++;
            return trips.subList(Math.min(n * size, trips.size()), Math.min((n + 1) * size, trips.size()));
        }
    }

    // The iterable collection: callers loop over trips; pages are fetched only when the loop needs them.
    static class TripHistory implements Iterable<Trip> {
        private final TripApi api;
        private final int pageSize;
        TripHistory(TripApi api, int pageSize) { this.api = api; this.pageSize = pageSize; }

        public Iterator<Trip> iterator() {
            return new Iterator<>() {
                private int pageNumber = 0, index = 0;
                private List<Trip> page = null;
                private boolean done = false;

                public boolean hasNext() {
                    if (done) return false;
                    if (page == null || index == page.size()) {
                        if (page != null && page.size() < pageSize) { done = true; return false; }
                        page = api.page(pageNumber++, pageSize);
                        index = 0;
                        if (page.isEmpty()) { done = true; return false; }
                    }
                    return true;
                }

                public Trip next() {
                    if (!hasNext()) throw new NoSuchElementException();
                    return page.get(index++);
                }
            };
        }
    }

    public static void main(String[] args) {
        TripApi api = new TripApi();
        List<Trip> october = new ArrayList<>();
        for (Trip trip : new TripHistory(api, 3)) {   // newest first, so stop at the first older trip
            if (!trip.month().equals("October")) break;
            october.add(trip);
        }
        List<String> parts = new ArrayList<>();
        int total = 0;
        for (Trip t : october) { parts.add(t.tripId() + " (" + t.minutes() + " min)"); total += t.minutes(); }
        System.out.println("October trips: " + String.join(", ", parts));
        System.out.println("October total: " + total + " min | pages fetched: " + api.pagesFetched + " of 4");

        api = new TripApi();
        Trip firstLong = null;
        for (Trip t : new TripHistory(api, 3)) if (t.minutes() > 30) { firstLong = t; break; }
        System.out.println("first trip over 30 minutes: " + firstLong.tripId() + " | pages fetched: " + api.pagesFetched);

        api = new TripApi();
        int count = 0;
        for (Iterator<Trip> it = new TripHistory(api, 3).iterator(); it.hasNext(); it.next()) count++;
        System.out.println("all trips: " + count + " | page requests: " + api.pagesFetched + " (the last comes back empty)");
    }
}