View
5
Download
0
Category
Preview:
Citation preview
RevolutieFunctioneel Programmeren
Java 8Johan Blok en Bart Barnard
����������
Van$java$8$alleen$functioneel$programmeren
\begin{programma}09.00 - 09.30:Inleiding09.30 - 10.00:sorteer- en filteropdrachten 10.00 - 10.30:terugkoppeling en theorie10.30 - 11.30:uitgebreidere opdrachten 11.30 - 12.00:gevolgen vakgebied en onderwijs\end{programma}
Inleiding
Het probleem
Intel Xeon processor 5600. (http://cdn.phys.org/newman/gfx/news/hires/Westmere-EP-Die.jpg)
http://www.cse.wustl.edu/~jain/cse567-11/ftp/multcore/
Java$richt$zich$meer$op$onderhoudbare$en$leesbare$code$dan$efficiënt$gebruik$van$clock<cycles$Programmacode$met$locks:$complex$en$foutgevoelig$Veel$gebruik$van$java.util.concurrent$Performance$gaat$zelfs$omlaag$naarmate$er$meer$cores$op$de$processor$komen
Imperatief versus FunctioneelImperatief:$reeks$instructies$die$toestand$veranderen
sum$=$0$$$for$$i=1$to$count(x)$ $$$$sum$=$sum$+$x[i]$$ average$=$sum$/$count(x)
Functioneel:$evaluatie$van$(wiskundige)$functies$
$ avg(x):$sum(x,$count(x))$/$count(x)$$ sum(x,$i):$$ $ if$(i>0)$$ $ $ sum(x,$i$–$1)$+$x[i]$$ $ else$0
Theorie: Lambda Calculus
✓ λ<calculus:$Formeel$systeem$ontwikkeld$rond$1930$door$Alonzo$Church$
✓ Hilbert’s$Entscheidungsproblem:$algoritme$dat$bepaalt$of$een$propositie$bewijsbaar$is$
✓ Lambda$Calculus$als$model$voor$berekenbaarheid$✓ 1980’s$typed$lambda$calculus:$constructive$mathematics
✓G.W.$Leibniz$(1646<1716)$✓Binair$getalstelsel$✓1671:$mechanische$rekenmachine$
✓Universele$denkmachine
Voordelen lambda expressies
✓Meer$directe$vertaling$van$de$bedrijfslogica$in$programmacode;$de$nadruk$op$functionaliteit$zorgt$voor$een$betere$flow$die$duidelijker$maakt$wat$er$moet$gebeuren$in$plaats$van$hoe$het$gebeurt.$
✓ Niet$meer$noodzakelijk$om$om$de$haverklap$objecten$te$creëeren$en$heen$en$weer$te$sturen.$$
$ Functies$gebruiken$als$parameters$$ Creëren$van$functies$in$andere$functies$$ Functies$als$return<type$✓ Veel$boilerplate$code$kan$worden$verwijderd:$duidelijkere$er$consistentere$code$
✓ Code$als$data:$objecten$kunnen$worden$gezien$als$data<containers
✓ Lambda$Expression$kan$anonieme$klasse$vervangen$✓ Collections:$filtering$✓ Predicates$✓Map$and$Reduce$✓ Type$inference
Java 8 overzicht http://javarevisited.blogspot.nl/2014/02/10<example<of<lambda<expressions<in<java8.html$
Java 8 Lambda Expression Syntax
button.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println("button clicked"); }});
new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println("button clicked"); }}
Anonymous$inner$class$$ ActionListener$heeft$één$methode:$actionPerformed()$$ Code$as$data:$we$sturen$een$object$mee$aan$de$methode$$ Te$veel$boilerplate$code$$ Is$onduidelijk$wat$de$programmeur$hiermee$bedoelt
button.addActionListener(event -> System.out.println("button clicked”));
event$is$de$parameter
->$scheidt$de$parameters$van$de$body$van$de$lambda$expressie
body$van$de$expressie;$in$plaats$van$een$object$geven$we$het$een$stuk$code$mee
Type4inference4javac$bepaalt$het$type$van$event$aan$de$hand$van$de$signature$van$addActionListener()
Java 8 Lambda Expression Syntax
Practicum 1: sorteren en filteren @Override public List<Student> imperative() { List<Student> list = data.getStudents(); list.sort(new Comparator<Student>() { public int compare(Student student1, Student student2) { return student1.getName().compareTo(student2.getName()); } }); return list; }
@Override public List<Student> functional() { List<Student> students = data.getStudents();! // TODO functional implementaton of sort by name! return students; }
Streams
External Iteration
Collection$CodeApplication$code
IterationhasNext()
hasNext
next()
next
Naar Warburton, 2014, p.18
int count = 0;Iterator<Artist> iterator = artists.iterator(); while(iterator.hasNext()) { Artist artist = iterator.next(); if (artist.isFrom("London")) { count++; }}
External Iteration
Internal Iteration
Collection$CodeApplication$code
Iteration
Naar Warburton, 2014, p.19
Build operation
Result
long count = allArtists.stream() .filter(artist -> artist.isFrom("London")) .count();
Internal Iteration
Source$Collection$/$List.stream()$Collection$/$List.parallelstream()$!
Intermediate$Operations$Filter4Map$/$Flatmap$Sorted$
!One$terminal$operation$Foreach$Collect4Reduce
Streams in Java 8
Operations in cursief worden even kort behandeld. Zie voor totaalbeeld Warburton, 2014, pp. 17-41.
Niet$te$verwarren$met$Input/outputstreams
Streams: Collect
List<String> foo = Stream.of("a", "b", "c") .collect(Collectors.toList());
collect(toList()) is$an$eager$operation$that$generates$a$list$from$the$values$in$a$Stream.
Streams: Filter
List<String> startsWithNr = Stream.of("a", "1abc", "abc1") .filter(value -> isDigit(value.charAt(0))) .collect(toList());
Any$time$you’re$looping$over$some$data$and$checking$each$element,$you$might$want$to$think$about$using$the$new$filter method$on$Stream.$
Streams: Map
List<String> foo = Stream.of("a", "b", "hello") .map(string -> string.toUpperCase()) .collect(toList());
If$you’ve$got$a$function$that$converts$a$value$of$one$type$into$another,$map$lets$you$apply$this$function$to$a$stream$of$values,$producing$another$stream$of$the$new$values.
Streams: ReduceIf$you’ve$got$a$function$that$converts$a$value$of$one$type$into$another,$map$lets$you$apply$this$function$to$a$stream$of$values,$producing$another$stream$of$the$new$values.
int count = IntStream.range(1,4) .reduce(0, (acc, element) -> acc + element);
1 2 3 4
1 6 103
initial result
acc
element
Predicates and type inference
public static Predicate<Employee> isAdultMale() { return p -> p.getAge() > 21 && p.getGender().equalsIgnoreCase("M");}
Predicates
public interface Predicate<T>{ boolean test(T t);}
Type inference
Map<String, Integer> foo = new HashMap<String, Integer>();Map<String, Integer> bar = new HashMap<>();
diamond$notation
old$($java$<$1.8)$method
useHashmap(new HashMap<>());...private void useHashmap(Map<String, String> values);
ook$in$dit$voorbeeld$is$javac$slim$genoeg$om$de$generics$van$de$nieuwe$HashMap$te$achterhalen.
Practicum 2: uitgebreidere voorbeelden
M
D | H
B | C F | G J | K | L
Q | T | X
N | P R | S V | W Y | Z
A B-tree whose keys are the consonants of the alphabet. An internal node x containing n[x] keys has n[x]+1 children. Alle leaves are at the same depths in the tree. The purple nodes are
examined in a search for the letter R.
Cormen et al.2005, p.435
Discussie: Functioneel Programmeren in het Vakgebied van de ICT
Krachtiger$expressies$Verkort$ontwikkeltijd$Minder$code,$minder$bugs$Unit$tests$Verwerking$datastromen$(big$data)$Performance?$Hoe$snel$in$bedrijfsleven$opgenomen?$In$het$nieuwe$curriculum?
LiteratuurCormen,$T.H.,$C.E.$Leiserson,$R.L.$Riverst,$C.$Stein,$2005,$Introduction4to4Algorithms.$Cambridge,$Mass:$MIT$Press$(second$edition).$!Hofstadter,$D.,$1980,$Gödel,4Escher,4Bach:4an4Eternal4Golden4Braid.$Pinguin.$!Michaelson,$G,$2011,$An4Introduction4to4Functional4Programming44Through4Lambda4Calculus,$NY:$Dover$Publications.$!Nagel,$E.$and$J.R.$Newman,$2001,$Gödel’s4Proof.$NYU$Press$!Warburton,$R,$2014,$Java484Lambdas.4Functional4Programming4for4the4Masses.$Sebastopol,$CA:$O’Reilly.
Recommended