Slicing streams: skip, limit, takeWhile and dropWhile

For this lesson, we'll focus on the operations that shape how much of a stream is traversed: skip, limit, takeWhile, dropWhile, pagination, infinite streams, ordered versus unordered behavior, ordered parallel costs, and the common interview question "how do you break from forEach?" Interviewers ask it because the happy path is tiny, but the edge cases reveal whether you understand encounter order and short-circuiting.

01Picture it first: cutting a queue with scissors

Picture a line of customers at a counter. skip(3) lets the first three leave without service, then the rest continue. limit(3) serves the next three customers and closes the counter. takeWhile(customer -> customer.hasTicket()) serves the front run of ticket-holders and stops at the first person without a ticket.

The phrase front run matters. takeWhile and dropWhile are about prefixes, not "all matching elements anywhere". If you want all matching elements, that is still filter.

Fig. 1

A stream of ordered elements is sliced by skip to drop the first two, limit to keep the next three, takeWhile to keep the leading passing prefix, and dropWhile to remove that same prefix

02skip and limit under the hood: counters with encounter order

Both skip and limit are intermediate operations. They do not do anything until a terminal operation asks for elements. In a sequential ordered stream, the mental model is two counters: one counter discards the first skip elements, and another counter stops after limit accepted elements.

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

final class SkipLimitOrderDemo {
    public static void main(String[] args) {
        List<Integer> first = IntStream.rangeClosed(1, 8)
                .skip(2)
                .limit(3)
                .boxed()
                .toList();

        List<Integer> second = IntStream.rangeClosed(1, 8)
                .limit(3)
                .skip(2)
                .boxed()
                .toList();

        System.out.println(first);
        System.out.println(second);
    }
}

The output is:

[3, 4, 5]
[3]

Notice three things.

• skip(2).limit(3) means "drop two, then take three".
• limit(3).skip(2) means "take three, then drop two from that small slice".
• Both operations care about encounter order when the stream has one, such as a List or IntStream.rangeClosed.

Negative arguments are not allowed. skip(-1) and limit(-1) throw IllegalArgumentException, which is better than quietly producing surprising slices.

03Pagination: readable, but not magic

For in-memory lists, the classic stream pagination line is:

List<Order> pageItems = orders.stream()
        .skip((long) page * size)
        .limit(size)
        .toList();

That is clear for small collections and one-off admin screens. It stops being enough when the source is large or remote. A stream over 1,000,000 sorted orders still has to advance past the skipped prefix before it can return the page.

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

final class PaginationCostDemo {
    public static void main(String[] args) {
        int page = 3;
        int size = 4;

        List<Integer> items = IntStream.rangeClosed(1, 30)
                .skip((long) page * size)
                .limit(size)
                .boxed()
                .toList();

        System.out.println(items);
    }
}

The output is:

[13, 14, 15, 16]

For page 10,000 with size 50, the skipped count is 500,000. In a database, do not stream every row to the JVM and then call skip. Push pagination to the query with an indexed order, or use keyset pagination when deep pages matter.