Prerequisite : Streams in java
The skip(long N) is a method of java.util.stream.Stream object. This method takes one long (N) as an argument and returns a stream after removing first N elements. skip() can be quite expensive on ordered parallel pipelines, if the value of N is large, because skip(N) is constrained to skip the first N elements in the encounter order and not just any n elements.
Note : If a stream contains less than N elements, then an empty stream is returned.
Syntax :
Stream<T> skip(long N) Where N is the number of elements to be skipped and this function returns new stream as output.
Exception : If the value of N is negative, then IllegalArgumentException is thrown by the function.
Example 1 : Implementation of skip function.
// Java code for skip() functionimport java.util.*;  class GFG {      // Driver code    public static void main(String[] args)    {          // Creating a list of integers        List<Integer> list = new ArrayList<Integer>();          // adding elements in the list        list.add(-2);        list.add(0);        list.add(2);        list.add(4);        list.add(6);        list.add(8);        list.add(10);        list.add(12);        list.add(14);        list.add(16);          // setting the value of N as 4        int limit = 4;        int count = 0;        Iterator<Integer> it = list.iterator();          // Iterating through the list of integers        while (it.hasNext()) {            it.next();            count++;              // Check if first four i.e, (equal to N)            // integers are iterated.            if (count <= limit) {                  // If yes then remove first N elements.                it.remove();            }        }          System.out.print("New stream is : ");          // Displaying new stream        for (Integer number : list) {            System.out.print(number + " ");        }    }} |
Output :
New stream is : 6 8 10 12 14 16
Application :
// Java code for skip() functionimport java.util.stream.Stream;import java.util.ArrayList;import java.util.List; class gfg{            // Function to skip the elements of stream upto given range, i.e, 3     public static Stream<String> skip_func(Stream<String> ss, int range){         return ss.skip(range);     }            // Driver code     public static void main(String[] args){                    // list to save stream of strings         List<String> arr = new ArrayList<>();                    arr.add("geeks");         arr.add("for");         arr.add("geeks");         arr.add("computer");         arr.add("science");                   Stream<String> str = arr.stream();                    // calling function to skip the elements to range 3         Stream<String> sk = skip_func(str,3);         sk.forEach(System.out::println);     } } |
Output :
computer science
Difference between limit() and skip() :
- The limit() method returns a reduced stream of first N elements but skip() method returns a stream of remaining elements after skipping first N elements.
- limit() is a short-circuiting stateful intermediate operation i.e, when processed with an infinite input, it may produce a finite stream as a result without processing the entire input but skip() is a stateful intermediate operation i.e, it may need to process the entire input before producing a result.
