Java 8 – Skip and Limit in Streams

Introduction

Java 8 introduced the Stream API, enabling developers to process collections of data in a functional and declarative manner. Two important methods in the Stream API are skip() and limit(). These methods allow you to control the number of elements that are processed in a stream. Specifically, skip() is used to skip the first N elements of a stream, while limit() is used to restrict the stream to a certain number of elements. Together, these methods provide powerful tools for handling large datasets or for scenarios where you need to process only a specific portion of a stream.

In this guide, we’ll explore how to use skip() and limit() in Java 8 streams with examples that demonstrate their practical applications.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Using skip() to Skip Elements in a Stream
  • Using limit() to Limit the Number of Elements in a Stream
  • Combining skip() and limit() for Pagination
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Demonstrates how to use the skip() method to skip a specified number of elements in a stream.
• Demonstrates how to use the limit() method to restrict the number of elements in a stream.
• Combines skip() and limit() to implement a simple pagination mechanism.

Example 1:

• Input: List of integers [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], skip the first 5 elements.
• Output: [6, 7, 8, 9, 10]

Example 2:

• Input: List of integers [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], limit the stream to 3 elements.
• Output: [1, 2, 3]

Example 3:

• Input: List of integers [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], skip the first 5 elements and limit the stream to 3 elements.
• Output: [6, 7, 8]

Solution Steps

1. Create a Stream: Start with a stream of elements (e.g., integers, strings).
2. Apply the skip() Method: Use skip() to skip a specified number of elements from the beginning of the stream.
3. Apply the limit() Method: Use limit() to restrict the stream to a certain number of elements.
4. Combine skip() and limit(): Combine these methods to implement pagination or other specific data processing tasks.

Java Program

Using skip() to Skip Elements in a Stream

The skip() method is used to skip the first N elements of a stream.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Using skip() to Skip Elements in a Stream
 * Author: https://www.rameshfadatare.com/
 */
public class StreamSkipExample {

    public static void main(String[] args) {
        // Step 1: Create a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Step 2: Skip the first 5 elements
        List<Integer> skippedNumbers = numbers.stream()
            .skip(5)
            .collect(Collectors.toList());

        // Step 3: Display the result
        System.out.println("After skipping first 5 elements: " + skippedNumbers);
    }
}

Output

After skipping first 5 elements: [6, 7, 8, 9, 10]

Explanation

• The numbers.stream() method creates a stream from the list of integers.
• The skip(5) method skips the first 5 elements in the stream.
• The collect(Collectors.toList()) method collects the remaining elements into a list.

Using limit() to Limit the Number of Elements in a Stream

The limit() method restricts the stream to a specified number of elements.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Using limit() to Limit the Number of Elements in a Stream
 * Author: https://www.rameshfadatare.com/
 */
public class StreamLimitExample {

    public static void main(String[] args) {
        // Step 1: Create a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Step 2: Limit the stream to the first 3 elements
        List<Integer> limitedNumbers = numbers.stream()
            .limit(3)
            .collect(Collectors.toList());

        // Step 3: Display the result
        System.out.println("First 3 elements: " + limitedNumbers);
    }
}

Output

First 3 elements: [1, 2, 3]

Explanation

• The numbers.stream() method creates a stream from the list of integers.
• The limit(3) method restricts the stream to the first 3 elements.
• The collect(Collectors.toList()) method collects these elements into a list.

Combining skip() and limit() for Pagination

You can combine skip() and limit() to implement a simple pagination mechanism.

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Combining skip() and limit() for Pagination
 * Author: https://www.rameshfadatare.com/
 */
public class StreamPaginationExample {

    public static void main(String[] args) {
        // Step 1: Create a list of integers
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Step 2: Skip the first 5 elements and limit the stream to 3 elements
        List<Integer> paginatedNumbers = numbers.stream()
            .skip(5)
            .limit(3)
            .collect(Collectors.toList());

        // Step 3: Display the result
        System.out.println("Paginated elements: " + paginatedNumbers);
    }
}

Output

Paginated elements: [6, 7, 8]

Explanation

• The numbers.stream() method creates a stream from the list of integers.
• The skip(5) method skips the first 5 elements.
• The limit(3) method limits the stream to the next 3 elements after skipping.
• The collect(Collectors.toList()) method collects these elements into a list.

Advanced Considerations

• Performance Considerations: Both skip() and limit() are efficient when processing large streams, but their performance may vary depending on the underlying data structure and the size of the dataset.

• Parallel Streams: When using skip() and limit() with parallel streams, ensure that the order of elements is preserved if it matters. The order can be guaranteed by using forEachOrdered() instead of forEach().

• Edge Cases: Be cautious when the skip value is greater than the number of elements in the stream or when the limit is larger than the remaining elements. In such cases, the methods behave gracefully by returning an empty or truncated stream.

Conclusion

This guide provides methods for using the skip() and limit() methods in Java 8 streams, demonstrating their use with different types of data, including integers and custom pagination. These methods are powerful tools for controlling the number of elements processed in a stream, making your code more flexible and efficient when handling large datasets or implementing pagination.