This document provides an overview of Java SE 8 Streams. It discusses how streams are wrappers around data sources that provide high performance operations using lambdas. Core stream methods like forEach(), map(), filter(), findFirst() are covered. Streams are lazy and can be parallelized. Streams output to common data structures like arrays and lists. Examples are provided to demonstrate creating streams from collections, using core stream methods, and converting streams back to pre-Java 8 data structures.

1. Java SE 8 :Streams
Streams Part 1
1. Overview of Streams
2. Standard Data Structures Into and Out of Streams
3. Core Stream Methods:
3.1 forEach(), map(), filter(), findFirst()
3.2 reduce(), collect(), min(), max(), sorted(), distinct(), limit(), skip(),
noneMatch(), allMatch(), anyMatch(), count()
4. Lazy Evaluation
5. Wrap Up
1Lars Lemos, MCA, OCPJP SE 6

2. Streams Overview
Stream Idea
 Streams are wrappers around data sources such as arrays or lists. They provide
many high performance operations that can be expressed with lambdas,
executed sequentially or in parallel.
Example: StreamSamples.java
 Note: Streams are not collections. This appear to be an interactive process for n elements over
each method operation. But due to Lazy evaluation there are less iterations performed over each
condition being met.
2
Lars Lemos, MCA, OCPJP SE 6

3. Streams Overview
Stream Idea
 Streams are “Not data structures”, they have no storage. They carry values
from a source through a pipeline of operations.
 Streams are “Designed for Lambdas”, streams operations take lambdas as
arguments.
 Streams don’t have “Indexed access”, you can access the first element, but
not the second or third.
 Streams output “Arrays or Lists” easily with simple syntax.
 Streams are “Lazy”, the operations are postponed until it is known how much
data is eventually needed.
Example: A operation that takes 10 s/item on a 100 element Stream, selecting the 1st
element takes 10s not 10000s
 Streams are “Parallelizable”, once a stream is designated as parallel, then
operations will automatically be done in parallel without having to write
explicit multi-threading code.
 Streams can “Ubounded”, once a generator function is designated, clients
can consume entries as long as they want, with values being generated on the
fly.
3
Lars Lemos, MCA, OCPJP SE 6

4. Streams Overview
Creating Stream
 It’s known that streams are not collections: they do not manage their own
data (wrappers around data structures).
 Thus a stream does not copy the underlying data, only builds a pipeline of
operations. And it can be invoked when desired.
Syntax:
• Individual values - Stream.of(val1, val2, …);
• Array - Stream.of(objectArray);
• Lists - someList.stream();
• StreamBuilder – someBuilder.build();
• String - Stream.of(somestring.split());
4
Lars Lemos, MCA, OCPJP SE 6

5. Streams Overview
Stream from Primitives
– Alternatives
• int[] nums = { 1, 2, 3, 4 };
• Arrays.stream(nums)… // IntStream
• Integer[] nums = { 1, 2, 3, 4 };
• Arrays.stream(nums)… or Stream.of(nums)… // Stream<Integer>
• Making 1-item stream by accident
– Mistake
• int[] nums = { 1, 2, 3, 4 };
• Stream.of(nums)… // 1-item Stream containing array
– Correct
• Integer[] nums = { 1, 2, 3, 4 };
• Stream.of(nums)… // 4-item Stream containing Integers 5
Lars Lemos, MCA, OCPJP SE 6

6. Streams Overview
Streams to Pre-Java 8 Data Structures
 Array
– strm.toArray(EntryType[]::new)
Examples: employeeStream.toArray(Employee[]::new)
– The argument to toArray is normally EntryType[]::new, but in general is a
Supplier that takes an int (size) as an argument and returns an empty array that
can be filled in.
 List
– strm.collect(Collectors.toList())
• Common to do “import static java.util.stream.Collectors.*;”
then to do strm.collect(toList())
 Other collections
– strm.collect(Collectors.toSet()), – strm.collect(Collectors.groupingBy(…)),
etc.
 String
– strm.collect(Collectors.toStringJoiner(delim)).toString()
6
Lars Lemos, MCA, OCPJP SE 6

7. Streams Overview
Core Streams Methods
 forEach(Consumer) : employees.forEach(e -> e.setSalary(e.getSalary() * 11/10))
Example: forEachExamples();
 map(Function) : ids.map(EmployeeUtils::findEmployeeById)
Example: mapExamples()
 filter(Predicate) : employees.filter(e -> e.getSalary() > 500000)
Example: filterExamples();
 findFirst() : employees.filter(…).findFirst().get()
Example: combinedExamples();
 collect(Collectors.toList()) : List<Employee> empList = employees.collect(Collectors.toList());
Example: lazyEvaluationExample();
7
Lars Lemos, MCA, OCPJP SE 6

8. Streams Overview
8
Lars Lemos, MCA, OCPJP SE 6
End of part II
Part III – JavaScript in JVM, Nashorn
…………
larslemos@gmail.com
Lars Lemos
toplars