Java 8 Streams

What is Stream in Java ?

Stream in Java is a sequence of elements on which operations can be performed. Stream operations can be intermediate or terminal. This definition sounds very similar to exisiting Collections.

What is difference between Collections and Streams

Collections is an in memory data structure which holds all the elements in the memory. In Stream the elements are computed on demand and the values are passed to next stream or returned. In Collection, the entire collection has to be computed to pass on to the next collection, whereas stream passes elements as it computes to the next Stream thus allowing Stream not to store the complete data set im memory.

Stream operations are terminal or intermediate and are combined to form stream pipelines. A stream pipeline consists of a source (such as a Collection, an array, a generator function, or an I/O channel); followed by zero or more intermediate operations such as Stream.filter or Stream.map and a terminal operation such as Stream.forEach or Stream.reduce. Terminal operations return a result of certain type and intermediate returns the Stream itself allowing to have multiple streams in a chain. Most of the stream operations take some kind of lambda expressions.

Types of Streams

Streams can be created from different sources and collections such as List and Set. The classes Stream, IntStream, LongStream, and DoubleStream are streams over objects and the primitive int, long and double types.

Streams can be generated:

  • From collections
    Arrays.asList("a1", "a2", "a3")
        .stream()
        .forEach(System.out::println)
        
        List l = new ArrayList() ;
        l.stream()
         .forEach(System.out::println)
  • Stream class static method
    Stream.of("a1", "a2", "a3")
        .stream()
        .forEach(System.out::println)
  • IntStream, DoubleStream static methods
    IntStream.range(1, 10)
        .forEach(System.out::println);

Note: forEach is a terminal function here

Mapping regular Stream to primitive Stream.

Sometimes it's useful to transform a regular object stream to a primitive stream or vice versa.

Stream.of("1", "2", "3")
  .mapToInt(Integer::parseInt)
  .average()
  .ifPresent(System.out::println);

IntStream.range(2013, 2016)
  .mapToObj(i -> "Year " + i)
  .forEach(System.out::println);

//Output
2.0

Year 2013
Year 2014
Year 2015

Stream Intermediate Functions

Intermediate functions returns the Stream itself, allowing to chain multiple such functions. Intermediate functions are lazily executed which means unless there is a terminal function append to Stream, the intermediate funciton will not be called. Some of commonly used functions:

  • filter():

    As name suggests, it is used for filtering the elements from this stream which doesn't satisy a criteria.

    IntStream.range(1,10)
    	.filter(num -> num%3 == 0)
    	.forEach(System.out::println);
    
  • map():

    Returns a stream consisting of the results of applying the given function to the elements of this stream

    Stream.of("mon", "tues", "wed", "thur", "fri", "sat", "sun")
      .map(String::toUpperCase)
      .forEach(System.out::println);
    
    //Output
    MON
    TUES
    WED
    THUR
    FRI
    SAT
    SUN
    
    //using filter with map
    Stream.of("mon", "tues", "wed", "thur", "fri", "sat", "sun")
      .map(String::toUpperCase)
      .filter(s -> s.contains("T"))
      .forEach(System.out::println);
    //OUTPUT
    TUES
    THUR
    SAT
    One thing to note is that the ordering in which the functions are defined matter and execution takes place in the similar manner.
  • sorted(): Returns the stream in a sorted manner.
    Stream.of("mon", "tues", "wed", "thur", "fri", "sat", "sun")
      .map(String::toUpperCase) 
      .sorted()
      .forEach(System.out::println);
    //Output
    FRI
    MON
    SAT
    SUN
    THUR
    TUES
    WED

Stream Terminal Functions

  • collect(): Used to convert the stream elements to collections
    Stream.of("mon", "tues", "wed", "thur", "fri", "sat", "sun")
      .map(String::toUpperCase)
      .collect(Collectors.toList())
    //to Set
    Stream.of("mon", "tues", "wed", "thur", "fri", "sat", "sun")
      .map(String::toUpperCase)
      .collect(Collectors.toSet())
  • forEach(): Performs an action for each element of this stream.
    Stream.of("mon", "tues", "wed", "thur", "fri", "sat", "sun")
      .map(String::toUpperCase) 
      .sorted()
      .forEach(System.out::println);
    //Output
    FRI
    MON
    SAT
    SUN
    THUR
    TUES
    WED
  • count(), sum(), average(): Self explanatory functions.
  • anyMatch(): Returns whether any elements of this stream match the provided predicate. It may not evaluate the predicate on all elements if not necessary for determining the result.
    boolean isPresent = IntStream.range(1,10)
      .anyMatch(num -> num %3 == 0);
    System.out.println(isPresent);
    //Output
    true
  • findFirst() :Will return the first element matching the Predicate.
    int num = IntStream.range(4,10)
      .filter(n -> n%3 ==0)
      .findFirst()
      .getAsInt();
    //Output
    6
  • findAny() :Will return some element matching the Predicate The behavior of the operation is nondeterministic. This is mainly used with parallel streams.
    int num = IntStream.range(4,10)
      .filter(n -> n%3 ==0)
      .findAny()
      .getAsInt();
    //Output
    6

Subscribe to get latest updates.