«Back to Home

Core Java
Topics

Streams In Java

Streams

Stream is an abstract layer, which is newly introduced in Java 8. With the help of stream, we can process the data in a declarative way similar to SQL statements.
 
For example

SELECT student_id, student_name FROM Student
 
This SQL statement automatically returns the student's details without doing any calculation on the programmer's end. By using collections framework, a programmer has to use loops and make repeated checks.
 
To resolve these types of issues, Java 8 introduced the concept of stream, which lets the programmer to process the data declaratively and influence multi-core architecture without the need to write any specific code for it.
 
Stream

Stream represents a sequence of objects from a source, which supports the aggregate operations.
 
Characteristics of a Stream

Sequence of elements − A stream gives a set of elements of a particular type in a sequential manner. A stream gets the elements on demand and it never stores the elements.
 
Source − Stream takes collections, arrays and I/O resources as an input source.
 
Aggregate operations − Stream holds the aggregate operations like filter, map, reduce, match etc.
 
Pipelining − Many stream operations return stream itself. Thus, their result can be pipelined. These operations are known as intermediate operations and their function are to take input, process them and return output to the target. The collect() method is a terminal operation, which is usually present at the end of the pipelining operation to mark the end of the stream.
 
Automatic iterations – A stream operations perform the iterations internally over the source elements provided and are in contrast to collections, where explicit iteration is required.
 
Generating Streams

In Java 8, collection interface has two methods to make a stream, which are,
 
stream() – This method is used to return a sequential stream consider collection as its source.
 
parallelStream() – This method is used to return a parallel stream, which considers collection as its source.
 
Some other important terms

forEach

Stream provides a new method ‘forEach’ to iterate each element of the stream.
 
map

The ‘map’ method maps each element to its corresponding result.
 
filter

The ‘filter’ method eliminates the elements, based on the criteria.
 
limit

The ‘limit’ method reduces the size of the stream.
 
sorted

The ‘sorted’ method sorts the stream.
 
Parallel Processing

For parallel processing, parallel stream is the alternative of stream and we can easily switch between the sequential streams and the parallel streams.
 
Collectors

Collectors combine the result of processing on the elements of a stream and it can be used to return a list or a string.
 
Statistics

Statistics collectors are used to calculate all the statistics, if the stream processing is being done.
 
Let’s see an example of streams, given below.
 
Code
  1. import java.util.ArrayList;  
  2. import java.util.Arrays;  
  3. import java.util.IntSummaryStatistics;  
  4. import java.util.List;  
  5. import java.util.Random;  
  6. import java.util.stream.Collectors;  
  7. import java.util.Map;  
  8. public class StreamsExample {  
  9.     public static void main(String args[]) {  
  10.         System.out.println("Java 7");  
  11.         List < String > strings = Arrays.asList("mia", "", "hi", "sam", "jack");  
  12.         System.out.println("List: " + strings);  
  13.         long count = getCountEmptyStringUsingJava7(strings);  
  14.         System.out.println("Null Strings: " + count);  
  15.         count = getCountLength3UsingJava7(strings);  
  16.         System.out.println("Strings of length 3: " + count);  
  17.         List < String > filtered = deleteEmptyStringsUsingJava7(strings);  
  18.         System.out.println("Filter List: " + filtered);  
  19.         String mergedString = getMergedStringUsingJava7(strings, ", ");  
  20.         System.out.println("Combined String: " + mergedString);  
  21.         List < Integer > numbers = Arrays.asList(3, 2, 2, 5);  
  22.         List < Integer > squaresList = getSquares(numbers);  
  23.         System.out.println("Squares List: " + squaresList);  
  24.         List < Integer > integers = Arrays.asList(1, 2, 13, 4);  
  25.         System.out.println("List: " + integers);  
  26.         System.out.println("Highest number : " + getMax(integers));  
  27.         System.out.println("Lowest number : " + getMin(integers));  
  28.         System.out.println("Sum of numbers : " + getSum(integers));  
  29.         System.out.println("Average of numbers : " + getAverage(integers));  
  30.         System.out.println("Random Numbers: ");  
  31.         Random random = new Random();  
  32.         for (int i = 0; i < 10; i++) {  
  33.             System.out.println(random.nextInt());  
  34.         }  
  35.         System.out.println("Java 8");  
  36.         System.out.println("List: " + strings);  
  37.         count = strings.stream().filter(string - > string.isEmpty()).count();  
  38.         System.out.println("Null Strings: " + count);  
  39.         count = strings.stream().filter(string - > string.length() == 3).count();  
  40.         System.out.println("Strings of length 3: " + count);  
  41.         filtered = strings.stream().filter(string - > !string.isEmpty()).collect(Collectors.toList());  
  42.         System.out.println("Filter List: " + filtered);  
  43.         mergedString = strings.stream().filter(string - > !string.isEmpty()).collect(Collectors.joining(", "));  
  44.         System.out.println("Combined String: " + mergedString);  
  45.         squaresList = numbers.stream().map(i - > i * i).distinct().collect(Collectors.toList());  
  46.         System.out.println("Squares List: " + squaresList);  
  47.         System.out.println("List: " + integers);  
  48.         IntSummaryStatistics stats = integers.stream().mapToInt((x) - > x).summaryStatistics();  
  49.         System.out.println("Highest number : " + stats.getMax());  
  50.         System.out.println("Lowest number : " + stats.getMin());  
  51.         System.out.println("Sum of numbers : " + stats.getSum());  
  52.         System.out.println("Average of numbers : " + stats.getAverage());  
  53.         System.out.println("Random Numbers: ");  
  54.         random.ints().limit(10).sorted().forEach(System.out::println);  
  55.         //parallel processing  
  56.         count = strings.parallelStream().filter(string - > string.isEmpty()).count();  
  57.         System.out.println("Empty Strings: " + count);  
  58.     }  
  59.     private static int getCountEmptyStringUsingJava7(List < String > strings) {  
  60.         int count = 0;  
  61.         for (String string: strings) {  
  62.             if (string.isEmpty()) {  
  63.                 count++;  
  64.             }  
  65.         }  
  66.         return count;  
  67.     }  
  68.     private static int getCountLength3UsingJava7(List < String > strings) {  
  69.         int count = 0;  
  70.         for (String string: strings) {  
  71.             if (string.length() == 3) {  
  72.                 count++;  
  73.             }  
  74.         }  
  75.         return count;  
  76.     }  
  77.     private static List < String > deleteEmptyStringsUsingJava7(List < String > strings) {  
  78.         List < String > filteredList = new ArrayList < String > ();  
  79.   
  80.         for (String string: strings) {  
  81.             if (!string.isEmpty()) {  
  82.                 filteredList.add(string);  
  83.             }  
  84.         }  
  85.         return filteredList;  
  86.     }  
  87.     private static String getMergedStringUsingJava7(List < String > strings, String separator) {  
  88.         StringBuilder stringBuilder = new StringBuilder();  
  89.         for (String string: strings) {  
  90.             if (!string.isEmpty()) {  
  91.                 stringBuilder.append(string);  
  92.                 stringBuilder.append(separator);  
  93.             }  
  94.         }  
  95.         String mergedString = stringBuilder.toString();  
  96.         return mergedString.substring(0, mergedString.length() - 2);  
  97.     }  
  98.     private static List < Integer > getSquares(List < Integer > numbers) {  
  99.         List < Integer > squaresList = new ArrayList < Integer > ();  
  100.         for (Integer number: numbers) {  
  101.             Integer square = new Integer(number.intValue() * number.intValue());  
  102.             if (!squaresList.contains(square)) {  
  103.                 squaresList.add(square);  
  104.             }  
  105.         }  
  106.         return squaresList;  
  107.     }  
  108.     private static int getMax(List < Integer > numbers) {  
  109.         int max = numbers.get(0);  
  110.         for (int i = 1; i < numbers.size(); i++) {  
  111.             Integer number = numbers.get(i);  
  112.             if (number.intValue() > max) {  
  113.                 max = number.intValue();  
  114.             }  
  115.         }  
  116.         return max;  
  117.     }  
  118.     private static int getMin(List < Integer > numbers) {  
  119.         int min = numbers.get(0);  
  120.         for (int i = 1; i < numbers.size(); i++) {  
  121.             Integer number = numbers.get(i);  
  122.             if (number.intValue() < min) {  
  123.                 min = number.intValue();  
  124.             }  
  125.         }  
  126.         return min;  
  127.     }  
  128.     private static int getSum(List numbers) {  
  129.         int sum = (int)(numbers.get(0));  
  130.         for (int i = 1; i < numbers.size(); i++) {  
  131.             sum += (int) numbers.get(i);  
  132.         }  
  133.         return sum;  
  134.     }  
  135.     private static int getAverage(List < Integer > numbers) {  
  136.         return getSum(numbers) / numbers.size();  
  137.     }  
  138. }  
13
14
15
16
17
18

Output

19
20

Summary

Thus, we learnt that the stream is an abstract layer, which is newly introduced in Java 8. With the help of stream, we can process the data in a declarative way similar to SQL statements and also learnt how to use it in Java.