Exploring Streams and Lambdas in Java8

Exploring Streams and Lambdas in
Java8
• Presented By:Isuru Samaraweera

Agenda
• Why change Java again?
• What is FP & Lambda?
• Functional Interfaces
• Streams
• Reduction
• Overloading Lambdas
• Advanced Collections and collectors
• Partioning and Grouping data
• Data Parrellelism
• Testing Lambdas

Why change java again
• Rise of the multicore CPUS
• Algorithms involves locks error-prone time
consuming
• Util.concurrent libraries have limititaions
• Lack of efficient parrelel operations on a
collection
• Java8 allows complex collection-processing
algorithms

What is fp
• Oop data abstraction/side efects
• Functional focuses on side effect free
• Pure functions/lambdas
• Pass functions around easeir to write lazy code
which initialises values when necessary
• n -> n % 2 != 0;
• (char c) -> c == 'y';
• (x, y) -> x + y;
• (int a, int b) -> a * a + b * b;

Functional Interfaces
• How does lambda expressions fit into Javas
type system?
• Each lambda corresponds to a given type,
specified by an interface
• exactly one abstract method declaration
• Interface with single abstract method used as
type
• Multiple optional default methods

Define a functional interface
@FunctionalInterface
public interface Calculator {
abstract int calculate(int x,int y);
}
public class FPDemo {
public static void main(String[] args) {
Calculator f=(x,y)->(x+y);
int z = f.calculate(3, 4);
System.out.println(z);
test((p,q)->p*q);
}
public static int test(Calculator cal) {
Return cal.calculate(4, 8);
}

Lambda Scopes
• int k=0;
• Calculator c1=
• (int x, int y)->
• {System.out.println(k);return x+y;};
• k=8;//fail to compile
• K is implicitly final
• Final is optional

Important functional interfaces in Java
• public interface Predicate<T> {
boolean test(T t);
}
• public interface Function<T,R> {
R apply(T t);
}
• public interface BinaryOperator<T> {
T apply(T left, T right);
}
public interface Consumer<T> {
void accept(T t);
}
• public interface Supplier<T> {
T get();
}

Predicate
• package com.java8.general;
• import java.util.Objects;
• import java.util.function.Predicate;
• public class PredicateTest {
• public static void main(String[] args) {
• Predicate<String> predicate = (s) -> s.length() > 0;
• boolean s=predicate.test("foo"); // true
• predicate.negate().test("foo");
• Predicate<Boolean> nonNull = Objects::nonNull;
• Predicate<Boolean> isNull = Objects::isNull;
• Predicate<String> isEmpty = String::isEmpty;
• Predicate<String> isNotEmpty = isEmpty.negate();
• }
• }

Functions
• Functions accept one argument and produce a
result.
• Function<String, Integer> toInteger =
Integer::valueOf;
• Function<String, Integer> toInteger=(s-
>Integer.valueOf(s);

Suppliers
• Suppliers produce a result of a given generic type.
Unlike Functions, Suppliers don't accept arguments.
• public class SupplierTest {
• public static void main(String[] args) {
• Supplier<SupplierTest> personSupplier =
SupplierTest::new;
• personSupplier.get(); // new Person
• }
• }

Consumers
• consumers represents operations to be
performed on a single input argument.
• Consumer<Person> greeter = (p) ->
System.out.println("Hello, " + p.firstName);
• greeter.accept(new Person("Luke",
"Skywalker"));

Comparators
• Comparator<Person> comparator = (p1, p2) ->
p1.firstName.compareTo(p2.firstName);
Person p1 = new Person("John", "Doe");
Person p2 = new Person("Alice",
"Wonderland");
• comparator.compare(p1, p2); // > 0

Type inference
• Predicate<Integer> atleast5=x->x>5;
• BinaryOperator<Long> addlngs=(x,y)->x+y;
• BinaryOperator add=(x,y)->x+y;

Streams
• A stream represents a sequence of elements
and supports different kind of operations to
perform computations upon those elements:
• List<String> myList =
• Arrays.asList("a1", "a2", "b1", "c2", "c1");
• myList.stream().filter(s -> s.startsWith("c"))
• .map(String::toUpperCase) .sorted()
• .forEach(System.out::println);

Traditional external iteration
• Int count=0;
• Iterator<Artist> iterator=allartists.iterator()
• While(iterator.hasNext())
• {Artist artist=iterator.next();
• If(artist.isForm(“NY”)
• Count++
• }
• Lot of boilerplate code and difficult concurrency
• Serial drawback

Internal Iterator with streams
• Long count=allartists.stream().filter(artist-
>artist.isFrom(“NY”)).count();
• Stream is tool for building up complex operations
on collections using functional approach
• If return is a stream its lazy-Intermediete stream
• If returns a value or void then its eager-Terminal
value

Terminal vs Lazy operations
• //does nothing
• artlist.stream().filter(artist->artist.isFrom("India"));
• //does nothing lazy inilitation
• artlist.stream().filter(artist-
>{System.out.println(artist.getName());
• return artist.isFrom("India");});
• long x=artlist.stream().filter(artist-
>{System.out.println(artist.getName());
• return artist.isFrom("India");}).count();
• System.out.println("x is"+x);

Common stream operations
• Collect(toList())
• Eager operation that genertes a list from the
values in a stream
• List<String>
collected=Stream.of("A","b","c").collect(Collec
tors.toList());
• Streams are lazy so u need eager operation
like collect

map
• Traditional uppercase conversion
• List<String> collected=new ArrayList<>();
• For(String string:asList(“a”,”b”,”c”)){
• String upper=string.toUpperCase();
• Collected.add(upper);
• }
• List<String>
mapped=Stream.of("A","b","c").map(string-
>string.toUpperCase()).collect(Collectors.toList());

filter
• Assume search strings start with a digit
• Traditional style-For loop and iterate
• Functional style
• List<String>
begwithn=Stream.of(“a”,”1abc”,”abc1”).filter(v
alue->isDigit(value.charAt(0))).collect(toList());
• Predicate interface returns true/false

sorted
• stringCollection .stream() .sorted() .filter((s) ->
s.startsWith("a"))
.forEach(System.out::println);
• Sorted is an intermediate operation which
returns a sorted view of the stream. The
elements are sorted in natural order unless
you pass a custom Comparator.

Map and Match
• stringCollection .stream()
.map(String::toUpperCase) .sorted((a, b) ->
b.compareTo(a)) .forEach(System.out::println);
• boolean anyStartsWithA = stringCollection
.stream() .anyMatch((s) -> s.startsWith("a"));

flatmap
• Replace a value with a stream and
concantenate all streams together
• List<Integer>
together=Stream.of(Arrays.asList(1,2),Arrays.a
sList(3,4)).flatMap(numbers-
>numbers.stream()).collect(toList());
• Flatmap return type is a stream

Max and min
• List<Track> tracks=Arrays.asList(new
Track("track1",524),new
Track("track2",454),new
Track("track3",444));
• Track
shortesttrack=tracks.stream().min(Comparator
.comparing(track->track.getLength())).get();
• Comparing builds a comparator using keys

Reduction Operations
• Terminal operations ( average, sum, min, max,
and count) that return one value by combining
the contents of a stream
• reduction operations that return a collection
instead of a single value.
• general-purpose reduction operations reduce
and collect

Reduce
Optional<T> reduce(BinaryOperator<T> accumulator)Performs a reduction on the elements of this stream, using
an associative accumulation function, and returns an Optional describing the reduced value, if any.
T reduce(T identity, BinaryOperator<T> accumulator)Performs a reduction on the elements of this stream, using
the provided identity value and an associative accumulation function, and returns the reduced value.
 U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator combiner)Performs a reduction on
the elements of this stream, using the provided identity, accumulation and combining functions.

Reduce with BinaryOperator
• persons
• .stream()
• .reduce((p1, p2) -> p1.age > p2.age ? p1 :
p2)
• .ifPresent(System.out::println);
• // Pamela
• Returns Optional

Reduce with identity and accumilator
• Integer totalAgeReduce = roster
• .stream()
• .map(Person::getAge)
• .reduce(
• 0,
• (a, b) -> a + b);
• identity: The identity element is both the initial value of the reduction and
the default result if there are no elements in the stream
• accumulator: The accumulator function takes two parameters: a partial
result of the reduction (in this example, the sum of all processed integers
so far) and the next element of the stream (in this example, an integer).
(a, b) -> a + b

Generic reduce
• a reduce operation on elements of type <T> yielding a
result of type 
• U reduce(U identity, BiFunction<U, ? super T, U>
accumulator, BinaryOperator combiner);
• identity element is both an initial seed value for the
reduction and a default result if there are no input
elements
• The accumulator function takes a partial result and the
next element, and produces a new partial result
• The combiner function combines two partial results to
produce a new partial result.

• List<String> test= new ArrayList<String>();
• test.add("isuru");
• test.add("sam");
• test.add("silva");
• int s = test.stream().reduce(0, (x, y) -> x + y.length(), (x, y) -> x + y);
• - identity - identity value for the combiner function
- reducer - function for combining two results
- combiner - function for adding an additional element into a result.
• When you run the stream in parallel, the task is spanned into
multiple threads. So for example the data in the pipeline is
partitioned into chunks that evaluate and produce a result
independently. Then the combiner is used to merge this results.

Putting all together
• Get all artists for album
• Figure out which artists are bands
• Find the nationalities for each band
• Put together a set of these values

• Set<String>
origins=album.getMusicians().filter(artist-
>artist.getName().startsWith(“The”)).map(arti
st->artist.getNationality()).collect(toSet());
• Filter,map are lazy operations
• Collect is eager

Stream misuse
• List<Artist>
musicians=album.getMusicians().collect(toList());
• List<Artist> bands=musicians.stream().filter(artist-
>artist.getName().startsWith(“The”)).collect(toList());
• Set<String> origins=bands.stream.map(artist-
>artist.getNationality().collect(toSet());
• Its harder to read /boiler plate code
• Less efficient because it requires eagerly creating new
collection objects in each intermediate step
• Clutters the code with intermediate variables
• Multithreading/parrelllism issues
• Chain them

Overloading
• private interface IntegerBiFunction extends
BinaryOperator<Integer>{}
• public void overloadedm1(BinaryOperator<Integer>
lambda)
• {
• System.out.println("Binaryoperator");
• }
• public void overloadedm1(IntegerBiFunction lambda)
• {
• System.out.println("Bifunction");
• }

• public void test()
• {
• overloadedm1( (y,x)->x+1);
• }
• If there are several possible target types the
most specific type is inferred

• private interface IntPredicate
• {
• public boolean test(int value);
• }
• public void overloadp1(Predicate<Integer> predicate)
• {
• System.out.println("Predicate");
• }
• public void overloadp1(IntPredicate predicate)
• {
• System.out.println("Intpredicate");
• }
• If there are several possible target types and there is no specific type you have to
manually provid the type

Binary interface compatibility
• Backward binary compatibility-If you compile
app in Java1 to 7 it will run out of the box in
Java8
• Stream method added to java8 Collection
iface
• Breaks the binary compatibility
• Not compile or Exception by Calssloader

Advanced Collections and Collectors
• Method references
• Artist:getName
• Artist:new
• String[] new

Element Ordering
• List<Integer> numbers=Arrays.asList(2,3,4);
• List<Integer>
sameOrder=numbers.stream().collect(Collectors.t
oList());
• Set<Integer> numberset=new
HashSet<>(Arrays.asList(3,4,5,6));
• List<Integer>
ntsameOrderset=numberset.stream().collect(Coll
ectors.toList());

Collector
• toList ,toSet you done give the complete
implementation
• Colelcting values into a collection of specific
type
• Stream.collec(toCollection(TreeSet ::new))

To Values
• Collect into a single value using collector
• Finding the band with most numbers
• public Optional<Artist>
biggestGroup(Stream<Artist> artists)
• {
• Funtion<Artist,Long> getCount=artist-
>artist.getMembers().count();
• Return
artists.collect(maxBy(comparing(getCount)));
• minBy also there

Partioning the data
• Split out a list
• Public Map<Boolean,List<Artist>>
bandsAndsolo(Stream<Artist> artists)
• {
• return artists.collect(partitionBy(artist-
>artist.isSolo()));
• }
• Or partitionBy(Artist::isSolo) method reference

Grouping the data
• Grouping albums by main artist
• Public Map<Artist,List<Album>>
albumsByArtists(Stream<Album> albums)
• {
• Return albums.collect(groupingBy(album-
>album.getMainMusician()));
• }

String
• Traditional String handling
• StringBuilder builder=new StringBuilder(“[“);
• For(Artist artist:artists)
• {
• If(builder.length()>1)
• Builder.apppend(“, “);
• }
• String name=artist.getName();
• Builder.append(name);
• }
• Builder.append(“]”);
• String result=builder.toString();
• String result=artists.stream().map(Artist::getName).collect(Collectors.joiniing(“, “,
“[“,”]”));

Composing collectors
• Naïve approach
• Map<Artist,List<Album>>
albumByArtist=albums.collect(groupingBy(album-
>album.getMainMusician())));
• Map<Artist,Integer> numberofalbums=new
HashMap<>();
• For(Entry<Artist,List<Album>
entry:albumsByArtist.entrySet()){
• Numberofalbums.put(entry.getKey(),entry.getVal
ue().size());

Using collectors to count the number
of albums for each artist
• Public Map<Artist,Long>
numberOfalbums(Stream<Album> albums)
• {Return albums.collect(groupingBy(album-
>album.getMusician(),counting())));
• }
• This grouping devides elements into buckets
• Reduction as a collector

Data paralleism
• Parellism vs Concurrency
• Concurrency arises when 2 tasks are making
progress at overlapping time periods
• Parrellism arises 2 tasks are hapenning at
same time –multicore cpu
• In single cpu-concurrency
• Multi core-concurrent/parrellel

Data parellism..contd
• Splitting up the data to be operated on and
assigning single processing unit to each chunk
of data
• Perform same operation on a large dataset
• Task parellism-each individual thread of
execution can be doing totally different task
• Java EE container TP

Parellel stream operations
• Serial summing of album trak lengths
• Public int serialArraySum(){
• Return
album.stream().flatmap(Album::gettracks).mapToInt(tr
ack:getLength).sum();
• }
• Public int parreelelArraySum(){
• Return
albums.parallelstream().flatMap(Album::gettracks).ma
pToInt(Track::getLength).sum();
• When 10000 albums are hit parrel code is faster

Testing Lambdas
• Public static List<String>
allToUppercase(List<String> words)
• {
• Return words.stream().map(string-
>string.toUpperCase()).collect(Collectors.<Stri
ng>.toList());
• }

• @Test
• Public void multiplewordsToUpperCase()
• {
• List<String> input=Arrays.asList(“a”,”b”,”hello”);
• List<String> result=Testing.allToUppercase(input);
• assertEquals(asList(“A”,”B”,”HELLO”),result);
• }

Exploring Streams and Lambdas in Java8

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Exploring Streams and Lambdas in Java8 (20)

Recently uploaded (20)

Exploring Streams and Lambdas in Java8