Java Stream skip

last modified May 25, 2025

This article demonstrates how to use the Java Stream skip method to bypass elements at the beginning of a stream.

The skip method is an intermediate operation in Java Streams that allows selective omission of the first N elements from a stream. It returns a new stream containing only the remaining elements, preserving their original order.

If the stream has fewer than N elements, an empty stream is returned, ensuring safe and predictable behavior in cases where the requested number of skipped elements exceeds the stream's size.

Basic skip syntax

The skip method allows you to bypass a specified number of elements at the start of a stream, returning a new stream with the remaining elements.

The method signature for skip is:

Stream<T> skip(long n)

The parameter n is the number of leading elements to skip. For ordered streams, the first n elements are discarded in encounter order. For unordered streams, any n elements may be discarded.

Skipping elements in ordered stream

You can use skip with ordered streams to ignore the first n elements and process the rest in their original order.

Basic usage with an ordered stream.

void main() {

    Stream.of("A", "B", "C", "D", "E", "F")
          .skip(3)
          .forEach(System.out::println);
}

This example skips the first 3 elements ("A", "B", "C") and processes the remaining elements ("D", "E", "F").

$ java Main.java
D
E
F

Skipping more elements than available

If you skip more elements than the stream contains, the result is an empty stream.

Behavior when skipping more elements than the stream contains.

void main() {

    long count = Stream.of(1, 2, 3)
                      .skip(5)
                      .count();
    
    System.out.println("Remaining elements: " + count);
}

This example attempts to skip 5 elements from a stream of only 3 elements, resulting in an empty stream with count 0.

$ java Main.java
Remaining elements: 0

Combining skip with limit

Combining skip and limit enables efficient pagination by selecting a specific range of elements from a stream.

Implementing pagination with skip and limit.

void main() {

    int pageSize = 5;
    int pageNumber = 2;
    
    IntStream.rangeClosed(1, 20)
             .skip(pageNumber * pageSize)
             .limit(pageSize)
             .forEach(System.out::println);
}

This example demonstrates pagination by skipping elements equivalent to previous pages and limiting to the current page size.

$ java Main.java
11
12
13
14
15

Skipping in unordered streams

When used with unordered streams, skip may discard any n elements, and the remaining elements have no guaranteed order.

Behavior with unordered streams.

void main() {

    Stream.of("A", "B", "C", "D", "E", "F")
          .unordered()
          .skip(3)
          .forEach(System.out::println);
}

With unordered streams, skip may discard any elements rather than strictly the first ones. The remaining elements maintain no particular order.

Skipping after filtering

The order of skip and filter affects which elements are skipped, as skip operates on the filtered stream.

Interaction between skip and filter operations.

void main() {

    IntStream.rangeClosed(1, 10)
             .filter(n -> n % 2 == 0) // even numbers
             .skip(2) // skip first 2 even numbers
             .forEach(System.out::println);
}

This example first filters even numbers (2, 4, 6, 8, 10) then skips the first 2 of those (2, 4), resulting in 6, 8, 10.

$ java Main.java
6
8
10

CSV processing

A common use case for skip is to ignore header rows when processing CSV data.

Skipping header rows in CSV data.

void main() {

    String csvData = """
        ID,Name,Age
        1,John,25
        2,Jane,30
        3,Bob,28
        """;
    
    Stream.of(csvData.split("\n"))
          .skip(1) // skip header row
          .map(line -> line.split(","))
          .forEach(fields -> System.out.println(
              "Name: " + fields[1] + ", Age: " + fields[2]));
}

This common use case demonstrates skipping the header row when processing CSV data.

$ java Main.java
Name: John, Age: 25
Name: Jane, Age: 30
Name: Bob, Age: 28

Source

Java Stream skip documentation

In this article we have explored the Java Stream skip method. It provides a convenient way to bypass leading elements in a stream, with particular usefulness in pagination scenarios and when processing structured data with headers.

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Java tutorials.