Stream skip() Method in Java With Examples

The Stream.skip(long n) method in Java is an important part of the Stream API which was introduced in Java 8. It enables developers to build pipelines of operations on data sets. The skip() method is especially useful for skipping a certain number of elements in a stream while processing the remaining elements.

Method Signature

Stream<T>: The method returns a new stream, which is also of the type T just as the original stream.

skip(long n): The name of the method skip itself indicates that it skips over elements in the stream. The parameter n indicates how many elements should be skipped.

long n: It is a single parameter of type long that shows the number of items to skip from the starting of the stream. If n is greater than the number of elements in the stream, the resulting stream will be empty.

Example 1: Skipping Elements in a List of Integers

In this example, we will create a list of integers named numbers containing the elements from 1 to 10. Then we will convert the list numbers into a stream the use of stream operations. The skip(5) method is called on the stream which skips the first 5 elements of the stream. The collect(Collectors.toList()) method collects the remaining elements of the stream into a new list.

Filename: SkipExample.java

Output:

 [6, 7, 8, 9, 10] 

Example 2: Skipping Even Numbers after Filtering and Squaring the Remaining Numbers

In this example, we will create a list of integers named numbers containing the elements from 1 to 10. The filter(n -> n % 2 == 0) method filters the stream to include only even numbers. The skip(2) method is called on the filtered stream which skips the first 2 elements of the filtered stream. The map(n -> n * n) method is used to square each remaining number in the stream. The collect(Collectors.toList()) method collects the squared numbers into a new list.

Filename: SkipWithConditionExample.java

Output:

 [36, 64, 100] 

Example 3: Skipping Strings that Match a Condition

In this example, we will create a list of strings named words containing various country names. Then convert the list words into a stream, enabling the use of stream operations. The filter(word -> word.startsWith("A")) method filters the stream to include only strings starting with the letter 'A'. The skip(2) method is called on the filtered stream which skips the first 2 elements of the filtered stream.

Filename: SkipWithConditionExample1.java

Output:

 [Austria] 

Example 4: Skipping Complex Objects Based on a Condition

In this example, we will create a list of Person objects named people, each initialized with a name and an age. The people.stream() converts the list of Person objects into a stream. The filter(person -> person.age > 30) filters the stream to include only persons older than 30 years. Then skip(1) method is called to skip the first person in the filtered stream.

Filename: SkipWithConditionExample2.java

Output:

 [Tom (40), Bob (50)] 

Example 5: Skipping Elements in a List of Strings and Converting to Uppercase

In this example, we will create a list of strings named words, containing the elements "one", "two", "three", "four", "five", "six", and "seven". The List<String> result = words.stream() converts the list words into a stream. The skip(3) method is called on the stream to skip the first 3 elements. The map(String::toUpperCase) method is used to convert each remaining string in the stream to uppercase.

Filename: SkipStringExample.java

Output:

 [FOUR, FIVE, SIX, SEVEN] 

Applications

1. Pagination

When dealing with large datasets, you often need to break the data into manageable chunks or pages. Skip elements to access a specific page of data. For example, if each page displays 10 items, to get the 3rd page, you would skip the first 20 items.

2. Load Balancing

In distributed systems or parallel processing where work needs to be divided among multiple processors or servers. Skip a portion of tasks to balance the load across different nodes, ensuring that each node processes a unique subset of tasks.

3. Sequential Data Processing

In time-series data or any sequential data processing where certain initial entries are to be disregarded. Skip a predefined number of initial entries to focus on a specific range within the data sequence.