Introduction

You may think that Stream must be similar to InputStream or OutputStream, but that’s not the case.

A Stream represents a sequence of elements supporting sequential and parallel aggregate operations. Stream does not store data, it operates on source data structures such as List, Collection, Array etc.

Most stream operations accept functional interfaces that make it a perfect candidate for lambda expressions.

If you are not well versed with functional interfaces, lambda expressions, and method references, you may want to read the following tutorials before moving ahead.

Types of Stream operations

There are two types of Stream operations.

1. Intermediate operations: return a stream that can be chained with other intermediate operations with dot .
2. Terminal operations: return void or non stream output.

Let’s understand with the help of simple example.

package org.arpit.java2blog.stream;

import java.util.Arrays;
import java.util.List;

public class StreamOperations {

    public static void main(String[] args) {
        List<String> stringList = Arrays.asList("John", "Martin", "Mary", "Steve");

        stringList.stream()
                   .map((s) -> s.toUpperCase())
                   .forEach(System.out::println);
    }
}

Output:

Here,
To perform a computation, stream operations are built into a Stream pipeline. Stream pipeline consists of:

1. source
2. zero or more intermediate operations
3. terminal operation.

In our example, Stream pipeline consists of:
Source: stringList
1 Intermediate operation: Map
1 terminal operation: forEach

The below diagram will make it more clear.
map is intermediate operation and foreach is terminal opertion.

Most stream operations accept parameters as that describes user-defined behaviour, such as lambda expression map((s)->s.toUpperCase()) is passed to map operation.

To get correct behavior, streams parameters should be:
non-interfering: Stream source should not be modified while execution of Stream pipline. You can learn more about interference.
Stateless: In most cases, lambda expressions should be stateless. Its output should not depend on state that might change during execution of Stream pipeline. I have already covered stateful lambda expression in Parallel Stream tutorial.

Stream creation

There are multiple ways to create the Stream.

Empty Stream

empty() method can be used to create an empty stream.

Stream s = Stream.empty()

It is generally used to return Stream with zero elements rather than null.

Collection Stream

Stream can be created from Collection by calling .stream() or .parallelStream()

List stringList=Arrays.asList("Andy","Peter","Amy","Mary");

stringList.stream()
.map((s)->s.toUpperCase())
.forEach(System.out::println);

stringList.stream() will return you regular object stream.

Stream.of

You don’t need to create collection to get a Stream. You can also use .of()

Stream streamArray =Stream.of("X","Y","Z");

Stream.generate()

generate() method accepts Supplier for element generation. It creates infinite Stream and you can limit it by calling limit() function.

Stream<Integer> intStream=Stream.generate(() -> 1).limit(5);
intStream.forEach(System.out::println);
// Output
// 1
// 1
// 1
// 1
// 1

This will create Integer stream with 10 elements with value 1.

Stream.iterate()

Stream.iterate() can also be used to generate infinite stream.

Stream<Integer> intStream = Stream.iterate(100 , n -> n+1).limit(5);
intStream.forEach(System.out::println);
// Output
// 100
// 101
// 102
// 103
// 104

First parameter of iterate method represents first element of the Stream. All the following elements will be generated by lambda expression n->n+1 and limit() is used to convert infinite Stream to finite Stream with 5 elements.

Lazy evaluation

Streams are lazy; intermediate operation are not executed until terminal operation is encounterd.

Each intermediate operation generates a new stream, stores the provided operation or function. When terminal operation is invoked, stream pipeline execution starts and all the intermediate operations are executed one by one.

Let’s understand with the help of example:

Stream<String> nameStream = Stream.of("mohan","john","vaibhav","amit");
Stream<String> nameStartJ = nameStream.map(String::toUpperCase)
                                    .peek( e -> System.out.println(e))
                                  .filter(s -> s.startsWith("J"));

System.out.println("Calling terminal operation: count");
long count = nameStartJ.count();
System.out.println("Count: "+ count);
// Output
// Calling terminal operation: count
// MOHAN
// JOHN
// VAIBHAV
// AMIT
// Count: 1

In preceding output, you can see that unless and until terminal operation count is called, nothing was printed on console.

In the preceding example, peek() method is used to print the element of stream. peek() method is generally used for logging and debugging purpose only.

Order of operations

Let’s see how stream processes the order of operations.
Could you guess output of the program?

Stream<String> nameStream = Stream.of("mohan","john","vaibhav","amit");
Stream<String> nameStartJ = nameStream.map(
        (s) ->
        {
            System.out.println("Map: "+s);
            return s.toUpperCase();

        })
        .filter(
        (s) ->
        {
             System.out.println("Filter: "+s);
             return s.startsWith("J");
        } 
    );

Optional<String> findAny = nameStartJ.findAny();
System.out.println("Final output: "+findAny.get());

Output will be:

Here order of operations might be surprising. A common approach will be to perform intermediate operation on all elements and then perform next operation, but instead each element moves vertically.

This kind of behavior can reduce actual number of operation.
For example:
In preceding example, Strings vaibhav and amit did not go through map and filter operation as we already got result(findAny()) with String john.

Some of the intermediate operations such as sorted are executed on the entire collection. As succeding operations might depend on the result of sorted operation.

Primitive Streams

Apart from regular Stream, Java 8 also provides primitive Stream for int, long and double.
Primitive Streams are:

1. IntStream for int
2. LongStream for long
3. DoubleStream for double

All the primitive Streams are similar to regular Stream with following differences.

• It supports few terminal aggregate functions such sum(), average(), etc.
• It accepts specialized function interface such as IntPredicate instead of Predicate, IntConsumer instead of Consumer.

Here is an example of an IntStream.

int sum = Arrays.stream(new int[] {1,2,3})
                .sum();
System.out.println(sum);

// Output 
// 6

Convert Stream to IntStream

You may need to convert Stream to IntStream to perform terminal aggregate operations such as sum or average. You can use mapToInt(), mapToLong() or mapToDouble() method to convert Stream to primitive Streams.
Here is an example:

Stream.of("10","20","30")
      .mapToInt(Integer::parseInt)
      .average()
      .ifPresent(System.out::println);
// Output
// 20.0

Convert IntStream to Stream

You may need to convert IntStream to Stream to use it as any other datatype. You can use mapToObj() convert primitive Streams to regular Stream.
Here is an example:

String collect = IntStream.of(10,20,30)
                          .mapToObj((i)->""+i)
                          .collect(Collectors.joining("-"));
System.out.println(collect);
// Output
// 10-20-30

Employee class

Consider a Employee class which has two fields name, age, listOfCities.

Here listOfCities denotes cities in which Employee has lived so far.

package org.arpit.java2blog.stream;

import java.util.List;

public class Employee implements Comparable{

    private String name;
    private int age;
    private List listOfCities;

    public Employee(String name, int age,List listOfCities) {
        super();
        this.name = name;
        this.age = age;
        this.listOfCities=listOfCities;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List getListOfCities() {
        return listOfCities;
    }

    public void setListOfCities(List listOfCities) {
        this.listOfCities = listOfCities;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(Employee o) {
        return this.getName().compareTo(o.getName());
    }
}

This Employee class will be used in all succeeding examples.
Let’s create employeesList on which we are going to perform intermediate and terminal operations.

package org.arpit.java2blog.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StreamGetListOfEmployees {

    public static void main(String[] args) {
        List employeesList=getListOfEmployees();

        // Write stream code here
    }

    public static List getListOfEmployees() {

        List listOfEmployees = new ArrayList<>();

        Employee e1 = new Employee("Mohan", 24,Arrays.asList("Newyork","Banglore"));
        Employee e2 = new Employee("John", 27,Arrays.asList("Paris","London"));
        Employee e3 = new Employee("Vaibhav", 32,Arrays.asList("Pune","Seattle"));
        Employee e4 = new Employee("Amit", 22,Arrays.asList("Chennai","Hyderabad"));

        listOfEmployees.add(e1);
        listOfEmployees.add(e2);
        listOfEmployees.add(e3);
        listOfEmployees.add(e4);

        return listOfEmployees;
    }
}

Common intemediate operations

Map()

Map() operation is used to convert Stream<T> to Stream<R>. It produces one output result of type 'R' for each input value of type 'T'. It takes Function interface as parameter.
For example:
You have stream of list of employees and you need a list of employee names, you simply need to convert Stream to Stream.

List<String> employeeNames = employeesList.stream()
                                .map(e -> e.getName())
                               .collect(Collectors.toList());
System.out.println(employeeNames);

// Output
// [Mohan, John, Vaibhav, Amit]

You can also use map even if it produces result of same type.
In case, you want employee name in uppercase, you can use another map() function to convert string to uppercase.

List<String> employeeNames = employeesList.stream()
                                .map(e -> e.getName())
                                .map(s -> s.toUpperCase())
                                .collect(Collectors.toList());
System.out.println(employeeNames);

// Output
// [MOHAN, JOHN, VAIBHAV, AMIT]

Filter()

Filter() operation is used to filter stream based on conditions. Filter method takes Predicate() interface which returns boolean value.
Let’s say you want to employees whose name starts with ‘A’.
You can write following functional code to achieve the same.

List<String> employeeNames = employeesList.stream()
                                .map(e -> e.getName())
                                .filter(s -> s.startsWith("A"))
                               .collect(Collectors.toList());
System.out.println(employeeNames);

// Output
// [AMIT]

sorted()

You can use sorted() method to sort list of objects. sorted method without arguments sorts list in natural order. sorted() method also accepts comparator as parameter to support custom sorting.

Did you know?

Natural order means sorting the list based on comparable interface implemented by list element type.
For example:
List will be sorted on the basis of comparable interface implemented by Integer class.

Here is the sorted() method example

List<Employee> employees = employeesList.stream()
                                            .sorted()
                                            .collect(Collectors.toList());
System.out.println(employees);

// Output
// [Employee [name=Amit, age=22], Employee [name=John, age=27], Employee [name=Mohan, age=24], Employee [name=Vaibhav, age=32]]

Here is the sorted() method example with Comparator as a parameter.

List<Employee> employees = employeesList.stream()
                              .sorted((e1,e2)->e1.getAge() - e2.getAge())
                               .collect(Collectors.toList());
System.out.println(employees);

// Output
// [Employee [name=Amit, age=22], Employee [name=Mohan, age=24], Employee [name=John, age=27], Employee [name=Vaibhav, age=32]]

You can also rewrite this with method reference as below:

List<Employee> employees = employeesList.stream()
                                                .sorted(Comparator.comparing(Employee::getAge))
                                                .collect(Collectors.toList());
System.out.println(employees);

// Output
// [Employee [name=Amit, age=22], Employee [name=Mohan, age=24], Employee [name=John, age=27], Employee [name=Vaibhav, age=32]]

limit()

You can use limit() to limit the number of elements in the stream.
For example:
limit(3) returns first 3 elements in the list.

Let’s see with the help of an example:

List<Employee> employees = employeesList.stream()
                                     .limit(3)
                                  .collect(Collectors.toList());
System.out.println(employees);

// Output
// [Employee [name=Mohan, age=24], Employee [name=John, age=27], Employee [name=Vaibhav, age=32]]

Skip()

skip(int n) method is used to discard first n elements from the stream.
For example:
skip(3) discards first 3 elements from stream.

Let’s see with help of example:

List<Employee> employees = employeesList.stream()
                                     .skip(3)
                                  .collect(Collectors.toList());
System.out.println(employees);

// Output
// [Employee [name=Amit, age=22]]

flatmap()

map() operation generates one output for each input element.

What if you want more than one output for each input?
flatmap() operation is exactly used for this purpose. It is used to map multiple-output for each input.
For example:
We want to accumulate list of cities in which all employees have lived. One employee could have lived in multiple cities so that we may have more than one city for each employee.

Let’s see with help of example:

List<String> listOfCities = employeesList.stream()
                                           .flatMap(e -> e.getListOfCities().stream())
                                           .collect(Collectors.toList());

System.out.println("listOfCities: " +listOfCities);

// Output
// listOfCities: [Newyork, Banglore, Paris, London, Pune, Seattle, Chennai, Hyderabad]

Common terminal operations

foreach

foreach() is terminal operation which is used to iterate over collection/stream of objects. It takes consumer as a parameter.

Let’s say you want to print elements of the stream.

employeesList.stream()
             .forEach(System.out::println);

// Output
// Employee [name=Mohan, age=24]
// Employee [name=John, age=27]
// Employee [name=Vaibhav, age=32]
// Employee [name=Amit, age=22]

collect

collect() is terminal operation which performs mutable reduction on the elements of Stream using Collector. Collectors is utility class which provides inbuilt Collector.
For example:
Collectors.toList() provides a Collector which converts Stream to a list object.
Following code accumultates Employee names into a Arraylist

List<String> employeeNames = employeesList.stream()
                                          .map(Employee::getName)
                                          .collect(Collectors.toList());
System.out.println(employeeNames);

// Output
// [Mohan, John, Vaibhav, Amit]

Reduce

The reduce operation combines all elements of Stream and produces single result.
Java 8 has three overloaded version of reduce method.

1. Optional<T> reduce(BinaryOperator<T> accumulator):
   This method takes BinaryOperator accumulator function. BinaryOperator is BiFunction where both the operands are of same type. First parameter is result till current execution, and second parameter is the current element of the Stream.

   Let’s find name of Person with minimum age.

   employeesList.stream()
   .reduce( (e1,e2)-> (e1.getAge() < e2.getAge()? e1:e2))
   .ifPresent(System.out::println);
   // Output
   // Employee [name=Amit, age=22]

2. T reduce(T identity, BinaryOperator accumulator):
   This method takes identity value and accumulator function. identity value is initial value of the reduction. If Stream is empty,then identity value is the result.
   Let’s find sum of all ages of Employees

   int sumAge = employeesList.stream()
   .mapToInt(Employee::getAge)
   .reduce(0, (age1,age2)-> (age1 + age2));
   
   System.out.println("Sum of ages of all Employees: "+sumAge);
   // Output
   // Sum of ages of all Employees: 105

3. <U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner):
   This method takes identity value and accumulator function and combiner. Combiner is mainy used in case of Parallel Streams. Combiner comibnes the result of sub-stream that run in Parallel.

count

count() is used to count number of elements in the stream.

long empCountStartJ = employeesList.stream()
                                   .map(Employee::getName)
                                   .filter(s -> s.startsWith("J"))
                                   .count();
System.out.println(empCountStartJ);

// Output
// 1

allMatch()

allMatch() returns true when all the elements in the stream meet provided condition.

This is a short-circuiting terminal operation because operation stops as soon as it encounters any unmatched element.

boolean allMatch = employeesList.stream()
                                .allMatch(e ->e.getAge()>18);

System.out.println("Are all the employess adult: " +allMatch);

// Output
// Are all the employess adult: true

nonMatch()

nonMatch() returns true when all the elements in the stream do not meet provided condition.

This is a short-circuiting terminal operation because operation stops as soon as it encounters any matched element.

boolean noneMatch = employeesList.stream()
                                 .noneMatch(e ->e.getAge()>60);

System.out.println("Are all the employess below 60: " +noneMatch);

// Output
// Are all the employess below 60: true

anyMatch()

anyMatch() returns true when any element in the stream meets provided condition.

This is a short-circuiting terminal operation because operation stops as soon as it encounters any matched element.

boolean anyMatch = employeesList.stream()
                                 .anyMatch(e ->e.getAge()>30);

System.out.println("is any employee's age greater than 30: " +anyMatch);

// Output
// is any employee's age greater than 30: true

min()

min(Comparator) returns minimum element in the stream based on the provided comparator. It returns an object which contains actual value.

Optional<Employee> minEmpOpt = employeesList.stream()
                                            .min(Comparator.comparing(Employee::getAge));

Employee minAgeEmp = minEmpOpt.get();
System.out.println("Employee with minimum age is: " +minAgeEmp);

// Output
// Employee with minimum age is: Employee [name=Amit, age=22]

max()

max(Comparator) returns maximum element in the stream based on the provided comparator. It returns an object which contains actual value.

Optional<Employee> maxEmpOpt = employeesList.stream()
                                            .max(Comparator.comparing(Employee::getAge));

Employee maxAgeEmp = maxEmpOpt.get();
System.out.println("Employee with maxium age is: " +maxAgeEmp);

// Output
// Employee with maxium age is: Employee [name=Vaibhav, age=32]

Parallel Streams

You can create Parallel Stream using .parallel() method on Stream object in java.
Here is an example:

int[] array= {1,2,3,4,5};

System.out.println("=================================");
System.out.println("Using Parallel Stream");
System.out.println("=================================");
IntStream intParallelStream=Arrays.stream(array).parallel();
intParallelStream.forEach((s)->
{
    System.out.println(s+" "+Thread.currentThread().getName());
}
);

Here is a comprehensive article on Java 8 Parallel Stream.

Exercises

Let’s practice some exercises on Stream.

Exercise 1

Given a list of employees, you need to find all the employees whose age is greater than 30 and print the employee names.(Java 8 APIs only)
Answer:

List<String> employeeFilteredList = employeeList.stream()
		                                          .filter(e->e.getAge()>30)
		                                          .map(Employee::getName)
		                                          .collect(Collectors.toList());
System.out.println(employeeFilteredList);

// Output
// Vaibhav

Exercise 2

Given the list of employees, find the count of employees with age greater than 25?
Answer:

List<Employee> employeeList = createEmployeeList();
long count = employeeList.stream()
                         .filter(e->e.getAge()>25)
                         .count();
System.out.println("Number of employees with age 25 are : "+count);
// Output
// Number of employees with age 25 are : 2

Exercise 3

Given the list of employees, find the employee whose name is John.

List<Employee> employeeList = createEmployeeList();
Optional<Employee> e1 = employeeList.stream()
		          .               .filter(e->e.getName().equalsIgnoreCase("John"))
                                          .findAny();
		        
if(e1.isPresent())
      System.out.println(e1.get());

Exercise 4

Given a list of employees, You need to find highest age of employee?
Answer:

List<Employee> employeeList = createEmployeeList();
OptionalInt max = employeeList.stream()
                              .mapToInt(Employee::getAge)
                              .max();
		        
if(max.isPresent())
       System.out.println("Maximum age of Employee: "+max.getAsInt());
// Output:
// Maximum age of Employee: 32

Excercise 5

Given a list of employees, you need sort employee list by age? Use java 8 APIs only
Answer:

List<Employee> employeesList = createEmployeeList();
List sortedList = employeesList.stream()
                                         .sorted((e1,e2)->e1.getAge()-e2.getAge())
                                         .collect(Collectors.toList());
sortedList.forEach(System.out::println);

// Output
// Employee [name=Amit, age=22]
// Employee [name=Mohan, age=24]
// Employee [name=John, age=27]
// Employee [name=Vaibhav, age=32]

Excercise 6

Given the list of Employees, you need to join the all employee names with ","?
Answer:

List<Employee> employeeList = createEmployeeList();
		List<String> employeeNames = employeeList
				                     .stream()
				                     .map(Employee::getName)
				                     .collect(Collectors.toList());
		String employeeNamesStr = String.join(",", employeeNames);
		System.out.println("Employees are: "+employeeNamesStr);
// Output
// Amit,Mohan,John,Vaibhav

Excercise 7

Given the list of employees, you need to group them by name

package org.arpit.java2blog;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class MaximumUsingStreamMain {
	public static void main(String args[])
	{
		List<Employee> employeeList = createEmployeeList();
		Map<String, List<Employee>> map = employeeList.stream()
				                              .collect(Collectors.groupingBy(Employee::getName));
		map.forEach((name,employeeListTemp)->System.out.println("Name: "+name+" ==>"+employeeListTemp));
	}
	
	public static List<Employee> createEmployeeList()
	{
		List<Employee> employeeList=new ArrayList<>();

		Employee e1=new Employee("John",21);
		Employee e2=new Employee("Martin",19);
		Employee e3=new Employee("Mary",31);
		Employee e4=new Employee("Mary",18);
		Employee e5=new Employee("John",26);

		employeeList.add(e1);
		employeeList.add(e2);
		employeeList.add(e3);
		employeeList.add(e4);
		employeeList.add(e5);

		return employeeList;
	}
}

Java 8 has introduced Stream.sort() method to sort list of elements conveniently. It helps us to write short and concise functional style code rather than boilerplate code.
java.util.Stream has two overloaded versions of sorted() method.

1. sorted(): Returns a stream having elements sorted by natural order
2. sorted(Comparator comparator): Returns a stream having elements sorted by provided comparator

Did you know?

If you sort list of Integers using Stream.sorted() method then Comparable interface, implemented by Integer class, will define natural ordering of list of Integers .

Let’s understand how can we use Stream.sorted() to sort list of elements.

Sort List of Integers

We can simply use sorted() method to sort list of integers.

List result = listOfIntegers.stream()
                                         .sorted()
                                         .collect(Collectors.toList());

Here, List of Integers is sorted by Comparable interface implemented by Integer class.

public final class Integer extends Number implements Comparable {
....
/**
     * Compares two {@code Integer} objects numerically.
     *
     * @param   anotherInteger   the {@code Integer} to be compared.
     * @return  the value {@code 0} if this {@code Integer} is
     *          equal to the argument {@code Integer}; a value less than
     *          {@code 0} if this {@code Integer} is numerically less
     *          than the argument {@code Integer}; and a value greater
     *          than {@code 0} if this {@code Integer} is numerically
     *           greater than the argument {@code Integer} (signed
     *           comparison).
     * @since   1.2
     */
    public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }

    /**
     * Compares two {@code int} values numerically.
     * The value returned is identical to what would be returned by:
     * 
     * Integer.valueOf(x).compareTo(Integer.valueOf(y))
     *
     *
     * @param  x the first {@code int} to compare
     * @param  y the second {@code int} to compare
     * @return the value {@code 0} if {@code x == y};
     *         a value less than {@code 0} if {@code x < y}; and
     *         a value greater than {@code 0} if {@code x > y}
     * @since 1.7
     */
    public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }

As you can see, Integers are compared on this basis of (x < y) ? -1 : ((x == y) ? 0 : 1) logic.

You can pass Comparator.reverseOrder() to sorted method to reverse sort list of Integers.

List reverseOrder = listOfIntegers.stream()
                                               .sorted(Comparator.reverseOrder())
                                               .collect(Collectors.toList());

Comparator.reverseOrder() is static method and provides a comparator that imposes reverse of natural ordering.

Let’s see complete example to sort list of integers.

package org.arpit.java2blog;

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

public class SortListOfIntegers {

    public static void main(String[] args) {
        List listOfIntegers = Arrays.asList(new Integer[] {40,34,21,37,20});

        List result = listOfIntegers.stream()
                                                .sorted()
                                                .collect(Collectors.toList());
        System.out.println(result);

        List reverseOrder = listOfIntegers.stream()
                                                     .sorted(Comparator.reverseOrder())
                                                     .collect(Collectors.toList());
        System.out.println(reverseOrder);
    }

}

Output:

Sort List of Strings

We can simply use sorted() method to sort list of Strings.

List result = listOfStrings.stream()
                                         .sorted()
                                         .collect(Collectors.toList());

Here, List of Strings is sorted by Comparable interface implemented by String class.

public final class String
    implements java.io.Serializable, Comparable, CharSequence {
....
/**
     * Compares two strings lexicographically.
     *
     * @param   anotherString   the {@code String} to be compared.
     * @return  the value {@code 0} if the argument string is equal to
     *          this string; a value less than {@code 0} if this string
     *          is lexicographically less than the string argument; and a
     *          value greater than {@code 0} if this string is
     *          lexicographically greater than the string argument.
     */
    public int compareTo(String anotherString) {
        int len1 = value.length;
        int len2 = anotherString.value.length;
        int lim = Math.min(len1, len2);
        char v1[] = value;
        char v2[] = anotherString.value;

        int k = 0;
        while (k < lim) {
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;
            }
            k++;
        }
        return len1 - len2;
    }

As you can see, Integers are compared on this basis of (x < y) ? -1 : ((x == y) ? 0 : 1) logic.

You can pass Comparator.reverseOrder() to sorted method to reverse sort list of Integers.

List reverseOrder = listOfStrings.stream()
                                               .sorted(Comparator.reverseOrder())
                                               .collect(Collectors.toList());

Comparator.reverseOrder() is static method and provides a comparator that imposes reverse of natural ordering.

Let’s see complete example to sort list of integers.

package org.arpit.java2blog;

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

public class SortListOfStrings {

    public static void main(String[] args) {
        List listOfLanguages = Arrays.asList(new String[] { "Python", "C++", "Java", "PHP" });

        List sortedListOfLanguages = listOfLanguages.stream()
                                                              .sorted()
                                                              .collect(Collectors.toList());
        System.out.println(sortedListOfLanguages);

        List sortedListOfLanguagesRev = listOfLanguages.stream()
                                                                 .sorted(Comparator.reverseOrder())
                                                                 .collect(Collectors.toList());
        System.out.println(sortedListOfLanguagesRev);  
    }

}

Output:

Sort List of custom objects

Sort list of Students by natural order

Create a class named Student.java

package org.arpit.java2blog;

public class Student{

    String name;
    int age;

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

Let’s use Stream’s sorted() to sort the list of Students now.

package org.arpit.java2blog;

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

public class SortListOfStudents {

    public static void main(String[] args) {
        List studentsList = getListOfStudents();

        List sortedStudentsList= studentsList.stream()
                                                          .sorted()
                                                          .collect(Collectors.toList());
        System.out.println(sortedStudentsList);
    }

    public static List getListOfStudents()
    {
        List studentList=new ArrayList<>();

        Student s1=new Student("Peter",21);
        Student s2=new Student("Harshal",18);
        Student s3=new Student("Andy",17);
        Student s4=new Student("Mary",20);
        Student s5=new Student("Peter",19);

        studentList.add(s1);
        studentList.add(s2);
        studentList.add(s3);
        studentList.add(s4);
        studentList.add(s5);

        return studentList;
    }
}

Let’s run above program.

Did you know why we got exception here?
We got the ClassCastException exception because we did not implement Comparable interface in Student class.

Let’s implement Comparable interface in Student class.

package org.arpit.java2blog;

public class Student implements Comparable{

    String name;
    int age;

    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }

    @Override
    public int compareTo(Student o) {
        return this.getName().compareTo(o.getName());
    }

}

Run SortListOfStudents again, and you will get below output.

As you can see, list of Students is sorted by student name.

Sort list of Students by reverse natural order

Sort list of Students by name in descending order.

package org.arpit.java2blog;

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

public class SortListOfStudents {

    public static void main(String[] args) {
        List studentsList = getListOfStudents();

        List sortedListOfStudent2 = listOfStudents.stream()
                                                           .sorted(Comparator.reverseOrder())
                                                           .collect(Collectors.toList());
        System.out.println(sortedStudentsList);
    }

    public static List getListOfStudents()
    {
        List studentList=new ArrayList<>();

        Student s1=new Student("Peter",21);
        Student s2=new Student("Harshal",18);
        Student s3=new Student("Andy",17);
        Student s4=new Student("Mary",20);
        Student s5=new Student("Peter",19);

        studentList.add(s1);
        studentList.add(s2);
        studentList.add(s3);
        studentList.add(s4);
        studentList.add(s5);

        return studentList;
    }
}

Output:

Sort list of Students by age using comparator

package org.arpit.java2blog;

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

public class SortListOfStudents {

    public static void main(String[] args) {
        List studentsList = getListOfStudents();

        List studentsListByAge = studentsList.stream()
                                                         .sorted((s1,s2) -> s1.getAge()-s2.getAge())
                                                         .collect(Collectors.toList());
        System.out.println(studentsListByAge);
    }

    public static List getListOfStudents()
    {
        List studentList=new ArrayList<>();

        Student s1=new Student("Peter",21);
        Student s2=new Student("Harshal",18);
        Student s3=new Student("Andy",17);
        Student s4=new Student("Mary",20);
        Student s5=new Student("Peter",19);

        studentList.add(s1);
        studentList.add(s2);
        studentList.add(s3);
        studentList.add(s4);
        studentList.add(s5);

        return studentList;
    }
}

Output:

You can also use Comparator.comparing(Function<? super T, ? extends U> keyExtractor) to sort it on the basis of age.
Comparator.comparing() accepts a function that maps a sort key from a type, and returns a Comparator that compares by that sort key.
Let’s say you want to sort list of Students on the basis of age. You can extracts sort key age from Student object and Comparator.comparing() will return a comparator which will sort by that sort key.

Function fun = (s) -> s.getAge();
    List studentsListByAge = studentsList.stream()
                                               .sorted(Comparator.comparing(fun))
                                               .collect(Collectors.toList());

Here Comparator.comparing() returns a new Comparator to sort based on age.

We can also use method reference here as we are just calling s.getAge() in the functional interface.

Function fun = Student::getAge
    List studentsListByAge = studentsList.stream()
                                            .sorted(Comparator.comparing(fun))
                                                .collect(Collectors.toList());

Let’s say you want to sort list of Students on the basis of age in descending order. You can pass another comparator to Comparator.comparing() to make custom sorting based on sort key.

List sortedListOfStudent5 = listOfStudents.stream()
                                                           .sorted(Comparator.comparing(Student::getAge,(age1,age2) -> age2 - age1))
                                                           .collect(Collectors.toList());

Here,
Comparator.comparing() has two arguments.
Student::getAge to define sort key.
(age1,age2) -> age2 - age1) to define custom sorting on the basis of sort key.

Here is the complete example.

package org.arpit.java2blog;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class SortListOfStudents {

    public static void main(String[] args) {
        List sList = getListOfStudents();

        Function fun = (s) -> s.getAge();
        List sListByAge = sList.stream()
                                         .sorted(Comparator.comparing(fun))
                                         .collect(Collectors.toList());
        System.out.println("Sorted list by age ascending: "+sListByAge);

        List sListByAgeRev = sList.stream()
                                           .sorted(Comparator.comparing(Student::getAge
                                                                         ,(age1,age2) -> age2 - age1))
                                           .collect(Collectors.toList());

        System.out.println("Sorted list by age descending: "+sListByAgeRev);
    }

    public static List getListOfStudents()
    {
        List studentList=new ArrayList<>();

        Student s1=new Student("Peter",21);
        Student s2=new Student("Harshal",18);
        Student s3=new Student("Andy",17);
        Student s4=new Student("Mary",20);
        Student s5=new Student("Peter",19);

        studentList.add(s1);
        studentList.add(s2);
        studentList.add(s3);
        studentList.add(s4);
        studentList.add(s5);

        return studentList;
    }
}

Output:

Sort list of Students by name and age

Let’s say you want to list of students by name and if name is same, then you need to sort by age.

You can use Comparator.thenComparing() with Comparator.comparing() to achieve the same.

Let’s see with the help of example.

package org.arpit.java2blog;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class SortListOfStudents {

    public static void main(String[] args) {
        List sList = getListOfStudents();

        List sListByNameAge = sList.stream()
                                           .sorted(Comparator.comparing(Student::getName)
                                                             .thenComparing(Student::getAge))
                                           .collect(Collectors.toList());

        System.out.println(sListByNameAge);
    }

    public static List getListOfStudents()
    {
        List studentList=new ArrayList<>();

        Student s1=new Student("Peter",21);
        Student s2=new Student("Harshal",18);
        Student s3=new Student("Andy",17);
        Student s4=new Student("Mary",20);
        Student s5=new Student("Peter",19);

        studentList.add(s1);
        studentList.add(s2);
        studentList.add(s3);
        studentList.add(s4);
        studentList.add(s5);

        return studentList;
    }
}

Output:

As you can see, there are two students named Peter in the list then, sorted by age.

package org.arpit.java2blog;

public class Employee {

    String name;

    public Employee(String name) {
        super();
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + "]";
    }
}

package org.arpit.java2blog;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class SortListOfEmployees {

	public static void main(String[] args) {
		List eList=getListOfEmployees();
		
		List eListDesc1 = eList.stream()
				                        .sorted((e1,e2) -> e2.getName().compareTo(e1.getName()))
		                                .collect(Collectors.toList());
		
		System.out.println(eListDesc1);
		
		List eListDesc2 = eList.stream().sorted(Comparator.comparing(Employee::getName
																			,(s1,s2)->s2.compareTo(s1)))
	                                              .collect(Collectors.toList());
		System.out.println(eListDesc2);
		
	}
	private static List getListOfEmployees() {
		
		List listOfEmployees=new ArrayList<>();
		
		Employee e1=new Employee("Shahid");
		Employee e2=new Employee("Anchit");
		Employee e3=new Employee("Chetan");
		Employee e4=new Employee("Vikrant");
		
		listOfEmployees.add(e1);
		listOfEmployees.add(e2);
		listOfEmployees.add(e3);
		listOfEmployees.add(e4);
		
		return listOfEmployees;
	}

}

That’s all about Java Stream sorted example.

Java Parallel Stream introduction

Java 8 introduces the concept of parallel stream to do parallel processing. As we have more number of cpu cores nowadays due to cheap hardware costs, parallel processing can be used to perform operation faster.

Let’s understand with help of simple example

package org.arpit.java2blog.java8;

import java.util.Arrays;
import java.util.stream.IntStream;

public class Java8ParallelStreamMain {

    public static void main(String[] args) {

        System.out.println("=================================");
        System.out.println("Using Sequential Stream");
        System.out.println("=================================");
        int[] array= {1,2,3,4,5,6,7,8,9,10};
        IntStream intArrStream=Arrays.stream(array);
        intArrStream.forEach(s->
        {
            System.out.println(s+" "+Thread.currentThread().getName());
        }
                );

        System.out.println("=================================");
        System.out.println("Using Parallel Stream");
        System.out.println("=================================");
        IntStream intParallelStream=Arrays.stream(array).parallel();
        intParallelStream.forEach(s->
        {
            System.out.println(s+" "+Thread.currentThread().getName());
        }
                );
    }
}

When you run above program, you will get below output

If you notice the output,main thread is doing all the work in case of sequential stream. It waits for current iteration to complete and then work on next iteration.
In case of Parallel stream,4 threads are spawned simultaneously and it internally using Fork and Join pool to create and manage threads.Parallel streams create ForkJoinPool instance via static ForkJoinPool.commonPool() method.

Parallel Stream takes the benefits of all available CPU cores and processes the tasks in parallel. If number of tasks exceeds the number of cores, then remaining tasks wait for currently running task to complete.

Parallel Streams are cool, so should you use it always?

A big No!!
It is easy to convert sequential Stream to parallel Stream just by adding .parallel, does not mean you should always use it.
There are lots of factors you need to consider while using parallel streams otherwise you will suffer from negative impacts of parallel Streams.

Parallel Stream has much higher overhead than sequential Stream and it takes good amount of time to coordinate between threads.
You need to consider parallel Stream if and only if:

• You have large dataset to process.
• As you know that Java uses ForkJoinPool to achieve parallelism, ForkJoinPool forks sources stream and submit for execution, so your source stream should be splittable.
  For example:
  ArrayList is very easy to split, as we can find a middle element by its index and split it but LinkedList is very hard to split and does not perform very well in most of the cases.
• You are actually suffering from performance issues.
• You need to make sure that all the shared resources between threads need to be synchronized properly otherwise it might produce unexpected results.

Simplest formula for measuring parallelism is "NQ" model as provided by Brian Goetz in his presentation.

package org.arpit.java2blog.java8;
import java.util.ArrayList;
import java.util.List;

public class PerformanceComparisonMain {

    public static void main(String[] args) {

        long currentTime=System.currentTimeMillis();
        List<Integer> data=new ArrayList<Integer>();
        for (int i = 0; i < 100000; i++) {
            data.add(i);
        }

        long sum=data.stream()
                .map(i ->(int)Math.sqrt(i))
                .map(number->performComputation(number))
                .reduce(0,Integer::sum);

        System.out.println(sum);
        long endTime=System.currentTimeMillis();
        System.out.println("Time taken to complete:"+(endTime-currentTime)/(1000*60)+" minutes");

    }

    public static int performComputation(int number)
    {
        int sum=0;
        for (int i = 1; i < 1000000; i++) {
            int div=(number/i);
            sum+=div;

        }
        return sum;
    }
}

long sum=data.stream()
                .parallel()
                .map(i ->(int)Math.sqrt(i))
                .map(number->performComputation(number))
                .reduce(0,Integer::sum);

ForkJoinPool fjp = new ForkJoinPool(parallelism);

ForkJoinPool fjp1 = new ForkJoinPool(5);
Callable callable1 = () -> data.parallelStream()
                   .map(i -> (int) Math.sqrt(i))
                   .map(number -> performComputation(number))
                   .peek( (i) -> {
                      System.out.println("Processing with "+Thread.currentThread()+" "+ i);

                    })
                    .reduce(0, Integer::sum);

        try {
            sumFJ1 = fjp1.submit(callable1).get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

package org.arpit.java2blog;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;

public class PerformanceComparisonMain {

    public static void main(String[] args) {

        List data = new ArrayList();
        for (int i = 0; i < 10; i++) {
            data.add(i);
        }

        System.out.println("================");
        System.out.println("Parallel stream 1");
        System.out.println("================");
        long sum1 =data.parallelStream()
        .map(i -> (int) Math.sqrt(i))
        .map(number -> performComputation(number))
        .peek( (i) -> {
           System.out.println("Processing with "+Thread.currentThread()+" "+ i);

           })
        .reduce(0, Integer::sum);

        System.out.println("Sum: "+sum1);

        System.out.println("================");
        System.out.println("Parallel stream 2");
        System.out.println("================");

        long sum2 = data.parallelStream()
                .map(i -> ((int) Math.sqrt(i)*10))
                .map(number -> performComputation(number))
                .peek( (i) -> {
                   System.out.println("Processing with "+Thread.currentThread()+" "+ i);

                   })
                .reduce(0, Integer::sum);

        System.out.println("Sum: "+sum2);

        System.out.println("================");
        System.out.println("Parallel stream with custom thread pool 1");
        System.out.println("================");

        ForkJoinPool fjp1 = new ForkJoinPool(5);
        long sumFJ1 = 0;

        Callable callable1 = () -> data.parallelStream()
                   .map(i -> (int) Math.sqrt(i))
                   .map(number -> performComputation(number))
                   .peek( (i) -> {
                      System.out.println("Processing with "+Thread.currentThread()+" "+ i);

                    })
                    .reduce(0, Integer::sum);

        try {
            sumFJ1 = fjp1.submit(callable1).get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("Sum: "+sumFJ1);

        System.out.println("================");
        System.out.println("Parallel stream with custom thread pool 2");
        System.out.println("================");

        Callable callable2 = () -> data.parallelStream()
                .map(i -> (int) Math.sqrt(i)*10)
                .map(number -> performComputation(number))
                .peek( (i) -> {
                   System.out.println("Processing with "+Thread.currentThread()+" "+ i);

                   })
                .reduce(0, Integer::sum);

        long sumFJ2 = 0;

        ForkJoinPool fjp2 = new ForkJoinPool(4);

        try {
            sumFJ2 = fjp2.submit(callable2).get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        System.out.println("Sum: "+sumFJ2);
    }

    public static int performComputation(int number) {
        int sum = 0;
        for (int i = 1; i < 100000; i++) {
            int div = (number / i);
            sum += div;

        }
        return sum;
    }
}

package org.arpit.java2blog;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class ListOfIntegersStatefulLambda {

    public static void main(String[] args) {

        List listOfIntegers = Arrays.asList(new Integer[] {40,34,21,37,20});
        List syncList = Collections.synchronizedList(new ArrayList<>());
        listOfIntegers.parallelStream()

                // You shou! It uses a stateful lambda expression.
                .map(e -> {
                    syncList.add(e);
                    return e;
                })
        .forEachOrdered(e -> System.out.print(e + " "));

        System.out.println("");

        syncList.stream().forEachOrdered(e -> System.out.print(e + " "));
        System.out.println("");
    }
}

package org.arpit.java2blog;

import java.util.ArrayList;
import java.util.List;

public class ListOfIntegersStatefulLambda {

    public static void main(String[] args) {

        List listOfIntegers = new ArrayList<>();
        Integer[] intArray =new Integer[] {40,34,21,37,20};
        for(Integer in:intArray)
        {
            listOfIntegers.add(in);
        }
        listOfIntegers.parallelStream()

        .peek( i -> listOfIntegers.add(7))      
        .forEach(e -> System.out.print(e + " "));

        System.out.println("");

    }
}

Stream<String> stringStream=Stream.of("India","China","Bhutan","Nepal");
Stream<Integer> integerStream=Stream.of(1,2,3,4,5);

package org.arpit.java2blog;

import java.util.stream.Stream;

public class Java8StreamOfExample {
    public static void main(String[] args)
    {
        Stream<String> stringStream=Stream.of("India","China","Bhutan","Nepal");

        stringStream.forEach((e) -> System.out.println(e));
    }
}

package org.arpit.java2blog.flatMap;

import java.util.stream.Stream;

public class Java8StreamOfExample {
    public static void main(String[] args)
    {
        Stream<Double> doubleStream=Stream.of(2.0,3.4,4.3);

        doubleStream.
        map(e -> 2*e)
        .forEach((e) -> System.out.println(e));
    }
}

<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)

String name;
int age;
List<String> listOfCities;

public Employee(String name, int age,List<String> listOfCities) {
    super();
    this.name = name;
    this.age = age;
    this.listOfCities=listOfCities;
}

public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}

public List<String> getListOfCities() {
    return listOfCities;
}

public void setListOfCities(List<String> listOfCities) {
    this.listOfCities = listOfCities;
}

public static void main(String args[])
{
    List<Employee> listOfEmployees = createListOfEmployees();

    Set<String> listOfCities=listOfEmployees.stream()
                                    .flatMap(e -> e.getListOfCities().stream()) 
                                    .collect(Collectors.toSet());
    listOfCities.forEach(System.out::println);
}       

public static List<Employee> createListOfEmployees()
{
    List<Employee> listOfEmployees=new ArrayList<>();
    Employee emp1= new Employee("Ankit",20,Arrays.asList("Delhi","Mumbai"));
    Employee emp2= new Employee("Shilpa",24,Arrays.asList("Kolkata","Pune"));
    Employee emp3= new Employee("Megha",20,Arrays.asList("Delhi","Patna"));
    Employee emp4= new Employee("Mohan",20,Arrays.asList("Banglore","Pune"));
    listOfEmployees.add(emp1);
    listOfEmployees.add(emp2);
    listOfEmployees.add(emp3);
    listOfEmployees.add(emp4);
    return listOfEmployees;
}

package org.arpit.java2blog.flatMap;

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Java8StreamFlatMapNumber {

    public static void main(String[] args)
    {
        int[][] numbers={
                {1,2},
                {3,4},
                {5,6}
        };
         //Stream<int[]>
        Stream<int[]> temp = Arrays.stream(numbers);
        List<Integer> listOfIntegers= temp
                .flatMap( x -> Arrays.stream(x).boxed())
                .map(e -> 2*e)
                .collect(Collectors.toList());

        System.out.println(listOfIntegers);

    }
}

<R> Stream<R> map(Function<? super T,? extends R>mapper)