Stream APIValdas Žigas · kaunas.jug@gmail.com · www.kaunas-jug.lt

{ λ }Java 8

Valdas Žigas

● 13.6 x JAVA

● KTU Programų inžinerija

● SCJP 1.5, PL/SQL OCA

● Oracle University Delivery Instructor

● LKSoft, BPI, Infor, Affecto. PSE, uTrack

Presentation Source Codehttps://github.com/valdasz/kaunasjug3streamapi.git

Java 8 { λ }. Impression

List<Long> idList = new ArrayList<>();

...

idList.stream().distinct().map(EmployeeStreamMain::

findById).filter(e -> e != null).filter(e -> e.getSalary() >

40000).findFirst().orElse(null);

Java 8 { λ }. Impression

12 Years Without Lambdas ...

java.util.stream.Stream<T> A sequence of elements supporting sequential

and parallel bulk operations

public interface Stream<T> extends BaseStream<T,

Stream<T>>

public interface BaseStream<T, S extends BaseStream<T,

S>> extends AutoCloseable

java.util.stream.BaseStream<T>

Simple example. forEachList<String> pronouns = Arrays.asList("i", "you", "he", "she", "it", "we", "you", "they");

pronouns.stream().forEach(p ->

System.out.println(p));

StreamFromListSimpleForEach.java

Simple example. forEach. Old schoolList<String> pronouns = Arrays.asList("i", "you", "he", "she", "it", "we", "you",

"they");

pronouns.stream().forEach(new Consumer<String>() {

public void accept(String p) {

System.out.println(p);

}

});

StreamFromListSimpleForEachOldStyle.java

Simple example. filterList<String> pronouns = Arrays.asList("i", "you", "he", "she", "it", "we", "you",

"they");

pronouns.stream().distinct().filter(p -> p.length() == 3).forEach(p ->

System.out.println(p));

StreamFromListSimpleFilter.java

Simple example. filter. Old schoolpronouns.stream().distinct().filter(new Predicate<String>() {

public boolean test(String p) {

return p.length() == 3;

}

}).forEach(new Consumer<String>() {

public void accept(String p) {

System.out.println(p);

}}); StreamFromListSimpleFilterOldStyle.java

● Collection.stream(),

Collection.parallelStream()

● Arrays.stream(T[])

● Stream.of(T...)

● IntStream.range(int, int)

● Stream.iterate(T,

UnaryOperator<T>)

Creating streams

Creating streams. Arrays.streamArrays.stream(new String[] { "This", "is", "Java8", "Stream" })

.forEach(System.out::println);

Arrays.stream(new Integer[] { 1, 2, 3 }).forEach(System.out::println);

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

StreamFromArraysStream.java

Creating streams. Stream.ofStream.of("This", "is", "Java8", "Stream").forEach(System.out::println);

Stream.of(new Integer[] { 1, 2, 3 }).forEach(System.out::println);

Stream.of(new int[] { 1, 2, 3 }).forEach(System.out::println);

StreamFromStreamOf.java

Creating streams. IntStreamIntStream.of(new int[] { 1, 2, 3 }).forEach(System.out::println);

IntStream.range(1, 3).forEach(System.out::println);

IntStream.rangeClosed(1, 3).forEach(System.out::println);

IntStreamFromIntStream.java

Creating streams. Infinite. Iteratestatic <T> Stream<T> iterate(T seed, UnaryOperator<T> f)

IntStream.iterate(1, p -> p + 2).limit(10).forEach(System.out::

println);

StreamFromStreamInfiniteIterate.java

Creating streams. Infinite. Generatestatic <T> Stream<T> generate(Supplier<T> s)

IntStream.generate(() -> (int) (System.nanoTime() % 100)).

limit(10)

.forEach(System.out::println);

StreamFromStreamInfiniteGenerate.java

Creating streams● BufferedReader.lines

● Random.ints()

● File.list

● Pattern.splitAsStream

● JarFile.stream()

● ……….. StreamFromBufferedReader.java

StreamFromPatternSplitAsStream.java

Stream features

● No Storage

● Functional in nature

● Laziness-seeking

● Possibly unbounded

● ConsumableStreamFunctional.java

StreamLaziness.javaStreamConsumable.java

Stream Operators

● Intermediate (filter, map, limit, sorted ..)

● Terminal (forEach, reduce, findFirst, sum,

collect..)

● Short-circuiting (intermediate/terminal: limit ..

/findFirst..)

Stream Operators. Intermediatemap (mapToInt, flatMap, ..), filter, distinct, sorted, peek, limit, substream, parallel,

sequential, unordered ..

● Return new Stream

● Always lazy

● Stateless/statefulfilter,map/distinct,sorted

● Some short-circuiting (limit)

Stream Operators. TerminalforEach, forEachOrdered, toArray, reduce, collect,

min, max, count, findFirst...

● Consumes pipeline/terminates

● Eager (except iterator,

spliterator)

● some short-circuiting (findFirst,

findAny)

Parallel Streams

● Collection.parallelStream()

BaseStream.parallel()

● same results as stream() apart

nondeterministic ops (findAny)

ParallelStreamFromListSimpleForEach.javaParallelStreamLaziness.java

Parallel Streams. Non-interference

seq: terminal op starts -> do not update

source -> terminal op ends.List<String> l = new ArrayList<String>(Arrays.asList("kaunas-jug", "meeting"));

Stream<String> sl = l.parallelStream();

l.add("#3");

String s = sl.collect(Collectors.joining(" "));

System.out.println(s);

NonInterference.java

Parallel Streams. Stateless behaviours

Best approach: avoid stateful behaviourSet<Integer> seen = Collections.synchronizedSet(new HashSet<>());

List<Integer> numbers = Arrays.asList(1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3);

List<Integer> result = numbers.parallelStream().map(e -> {return seen.add(e) ? 0 : e;

}).collect(Collectors.toList());

StatefulBehaviour.java

Parallel Streams. reduce. Associativity

(a op b) op c == a op (b op c)

a op b op c op d == (a op b) op (c op d)

IntStream stream = IntStream.rangeClosed(1, 4).

parallel();

OptionalInt rez = stream.reduce((x, y) -> x - y)ReduceAssociativity.java

System.exit(0)

Thank You !