Java SE 8 best practices

Stephen Colebourne

More Related Content

1.Java SE 8 Best PracticesA personal viewpointStephen Colebourne, October 2015
2.Agenda● ⇒ Introduction● λ Lambdas● f⒳ Functional interfaces● ! Exceptions● ? Optional● ♒ Streams● I Interfaces● Date and Time● Extras
3.Introduction⇒
4.Introduction● What is a Best Practice?
5.Introduction● What is a Best Practice?"commercial or professional proceduresthat are accepted or prescribed as beingcorrect or most effective"
6.Introduction● What is the Best Practice for Java SE 8?
7.Introduction● What is the Best Practice for Java SE 8?"whatever I say in the next 50 minutes"
8.Introduction● Software Best Practice is mostly opinion● Different conclusions perfectly possible● My opinions are based on over a year using Java SE 8
9.Introduction● Software Best Practice is mostly opinion● Different conclusions perfectly possible● My opinions are based on over a year using Java SE 8But you must exercise your own judgement!
10.Java SE 8 version● Use Java SE 8 update 40 or later○ preferably use the latest available● Earlier versions have annoying lambda/javac issuesBestPractice
11.Lambdasλ
12.Lambdas● Block of code○ like an anonymous inner class● Always assigned to a Functional Interface○ an interface with one abstract method● Uses target typing○ context determines type of the lambda
13.Lambdas - Example// Java 7List<Person> people = loadPeople();Collections.sort(people, new Comparator<Person>() {@Overridepublic int compare(Person p1, Person p2) {return p1.name.compareTo(p2.name);}});
14.Lambdas - Example// Java 7List<Person> people = loadPeople();Collections.sort(people, new Comparator<Person>() {@Overridepublic int compare(Person p1, Person p2) {return p1.name.compareTo(p2.name);}});
15.Lambdas - Example// Java 8List<Person> people = loadPeople();Collections.sort(people,(Person p1, Person p2)p1.name.compareTo(p2.name));
16.Lambdas - Example// Java 8List<Person> people = loadPeople();Collections.sort(people,(Person p1, Person p2) -> p1.name.compareTo(p2.name));
17.Lambdas - Example// Java 8List<Person> people = loadPeople();Collections.sort(people,(Person p1, Person p2) -> p1.name.compareTo(p2.name));
18.Lambdas - Example// Java 8List<Person> people = loadPeople();Collections.sort(people,(p1, p2) -> p1.name.compareTo(p2.name));
19.Lambdas - Example// Java 8List<Person> people = loadPeople();people.sort((p1, p2) -> p1.name.compareTo(p2.name));
20.Lambdas● Make use of parameter type inference● Only specify the types when compiler needs it// prefer(p1, p2) -> p1.name.compareTo(p2.name);// avoid(Person p1, Person p2) -> p1.name.compareTo(p2.name);BestPractice
21.Lambdas● Do not use parameter brackets when optional// preferstr -> str.toUpperCase(Locale.US);// avoid(str) -> str.toUpperCase(Locale.US);BestPractice
22.Lambdas● Do not declare local variables as 'final'● Use new "effectively final" conceptpublic UnaryOperator<String> upperCaser(Locale locale) {return str -> str.toUpperCase(locale);}BestPracticeDo not declare as 'final'
23.Lambdas● Prefer expression lambdas over block lambdas● Use a separate method if necessary// preferstr -> str.toUpperCase(Locale.US);// use with carestr -> {return str.toUpperCase(Locale.US);}BestPractice
24.Lambas for Abstraction● Two large methods contain same code● Except for one bit in the middle● Can use a lambda to express the difference
25.Lambas for Abstractionprivate int doFoo() {// lots of code// logic specific to method1// lots of code}private int doBar() {// lots of code// logic specific to method2// lots of code}
26.Lambas for Abstractionprivate int doFoo() {return doFooBar( lambdaOfFooSpecificLogic );}private int doFooBar(Function<A, B> fn) {// lots of coderesult = fn.apply(arg)// lots of code}BestPractice
27.Example Abstractiondouble[][] res = new double[rowCount][colCount];for (int i = 0; i < rowCount; ++i) {for (int j = 0; j < colCount; ++j) {res[i][j] = pp.getCoefMatrix().get(i, j) * (nCoefs - j - 1);}}DoubleMatrix2D coef = new DoubleMatrix2D(res);
28.Example AbstractionDoubleMatrix2D coef = DoubleMatrix2D.of(rowCount,colCount,(i, j) -> pp.getCoefMatrix().get(i, j) * (nCoefs - j - 1));// new methodpublic static DoubleMatrix2D of(int rows, int columns, IntIntToDoubleFunction valueFunction)
29.Functional interfacesf⒳
30.Functional interfaces● An interface with a single abstract method○ Runnable○ Comparable○ Callable● Java SE 8 adds many new functional interfaces○ Function<T, R>○ Predicate<T>○ Supplier<T>○ Consumer<T>○ see java.util.function package
31.Functional interfaces● Learn java.util.function package interface● Only write your own if extra semantics are valuable● If writing one, use @FunctionalInterface@FunctionalInterfacepublic interface FooBarQuery {public abstract Foo findAllFoos(Bar bar);}BestPractice
32.Higher order methods● Methods accepting lambdas are nothing special○ declared type is just a normal interface● However there are some subtletiesprivate String nameGreet(Supplier<String> nameSupplier) {return "Hello " + nameSupplier.get();}// caller can use a lambdaString greeting = nameGreet(() -> "Bob");
33.Avoid method overloads● Lambdas use target typing● Clashes with method overloading// avoidpublic class Foo<T> {public Foo<R> apply(Function<T, R> fn);public Foo<T> apply(UnaryOperator<T> fn);}
34.Avoid method overloads● Lambdas use target typing● Clashes with method overloading● Use different method names to avoid clashesBestPractice// preferpublic class Foo<T> {public Foo<R> applyFunction(Function<T, R> fn);public Foo<T> applyOperator(UnaryOperator<T> fn);}
35.Functional interface last● Prefer to have functional interface last○ when method takes mixture of FI and non-FI● Mostly stylistic○ slightly better IDE error recoveryBestPractice// preferpublic Foo parse(Locale locale, Function<Locale,Foo> fn);// avoidpublic Foo parse(Function<Locale,Foo> fn, Locale locale);
36.Exceptions!
37.Checked exceptions● Most functional interfaces do not declare exceptions● No simple way to put checked exceptions in lambdas// does not compile!public Function<String, Class> loader() {return className -> Class.forName(className);}Throws a checked exception
38.Checked exceptions● Write or find a helper method● Converts checked exception to uncheckedpublic Function<String, Class> loader() {return Unchecked.function(className -> Class.forName(className));}BestPractice
39.Checked exceptions● Helper methods can deal with any block of code○ convert to runtime exceptions● May be a good case for a block lambdaUnchecked.wrap(() -> {// any code that might throw a checked exception});
40.Testing for exceptions● Complete unit tests often need to test for exceptionspublic void testConstructorRejectsEmptyString() {try {new FooBar("");fail();} catch (IllegalArgumentException ex) {// expected}}
41.Testing for exceptions● Use a helper method● Lots of variations on this theme are possiblepublic void testConstructorRejectsEmptyString() {TestHelper.assertThrows(IllegalArgumentException.class, () -> new FooBar(""));}BestPractice
42.Optional and null?
43.https://www.flickr.com/photos/bigmacsc99/4003751542/Boom!
44.Optional and null● New class 'Optional' added to Java 8● Polarizes opinions○ functional programming dudes think it is the saviour of the universe● Simple concept - two states○ present, with a value - Optional.of(foo)○ empty - Optional.empty()
45.Optional and null● Standard code using null// library, returns null if not foundpublic Foo findFoo(String key) { … }// application codeFoo foo = findFoo(key);if (foo == null) {foo = Foo.DEFAULT; // or throw an exception}
46.Optional and null● Standard code using Optional// library, returns null if not foundpublic Optional<Foo> findFoo(String key) { … }// application codeFoo foo = findFoo(key).orElse(Foo.DEFAULT);// orFoo foo = findFoo(key).orElseThrow(RuntimeException::new);
47.Optional and null● Variable of type Optional must never be null● Never ever● Never, never, never, never!BestPractice
48.Optional● Prefer "functional" methods like 'orElse()'● using 'isPresent()' a lot is misusing the featureBestPractice// preferFoo foo = findFoo(key).orElse(Foo.DEFAULT);// avoidOptional<Foo> optFoo = findFoo(key);if (optFoo.isPresent()) { … }
49.Optional● Have a discussion and choose an approachA. Use everywhereB. Use instead of null on public APIs, input and outputC. Use instead of null on public return typesD. Use in a few selected placesE. Do not useBestPractice
50.Optional● Have a discussion and choose an approachA. Use everywhereB. Use instead of null on public APIs, input and outputC. Use instead of null on public return types↖ my preferred choice ↗D. Use in a few selected placesE. Do not useBestPractice
51.Optional● Optional is a class● Some memory/performance cost to using it● Not serializable● Not ideal to be an instance variable● JDK authors added it for return types● Use in parameters often annoying for callers● Use as return type gets best value from concepthttp://blog.joda.org/2015/08/java-se-8-optional-pragmatic-approach.html
52.Streams♒
53.Streams● Most loops are the same● Repetitive design patterns● Stream library provides an abstraction● Lambdas used to pass the interesting bits
54.StreamsList<Trade> trades = loadTrades();List<Money> valued = new ArrayList<Money>();for (Trade t : trades) {if (t.isActive()) {Money pv = presentValue(t);valued.add(pv);}}Loop to build outputlist from inputOnly interested insome tradesConverts each tradeto the money value
55.StreamsList<Trade> trades = loadTrades();List<Money> valued = new ArrayList<Money>();for (Trade t : trades) {if (t.isActive()) {Money pv = presentValue(t);valued.add(pv);}}
56.StreamsList<Trade> trades = loadTrades();List<Money> valued = new ArrayList<Money>();for (Trade t : trades) {if (t.isActive()) {Money pv = presentValue(t);valued.add(pv);}}
57.StreamsList<Trade> trades = loadTrades();List<Money> valued = Listtradest.isActive()presentValue(t)
58.StreamsList<Trade> trades = loadTrades();List<Money> valued = // List// trades// t.isActive()// presentValue(t)
59.StreamsList<Trade> trades = loadTrades();List<Money> valued = // Listtrades.stream() // trades// t.isActive()// presentValue(t)
60.StreamsList<Trade> trades = loadTrades();List<Money> valued = // Listtrades.stream() // trades.filter(t -> t.isActive()) // t.isActive()// presentValue(t)
61.StreamsList<Trade> trades = loadTrades();List<Money> valued = // Listtrades.stream() // trades.filter(t -> t.isActive()) // t.isActive().map(t -> presentValue(t)) // presentValue(t)
62.StreamsList<Trade> trades = loadTrades();List<Money> valued = // Listtrades.stream() // trades.filter(t -> t.isActive()) // t.isActive().map(t -> presentValue(t)) // presentValue(t).collect(Collectors.toList());
63.StreamsList<Trade> trades = loadTrades();List<Money> valued =trades.stream().filter(t -> t.isActive()).map(t -> presentValue(t)).collect(Collectors.toList());
64.Streams● Streams are great, sometimes● Important not to get carried away● Design focus was on Collections, not Maps● Key goal was simple parallelism
65.StreamsList<Trade> trades = loadTrades();List<Money> valued =trades.stream().filter(t -> t.isActive()).map(t -> presentValue(t)).collect(Collectors.toList());
66.StreamsList<Trade> trades = loadTrades();List<Money> valued =trades.parallelStream().filter(t -> t.isActive()).map(t -> presentValue(t)).collect(Collectors.toList());
67.Streams● Do not overdo it● Stream not always more readable than loop● Good for Collections, less so for Maps● Don't obsess about method references○ IntelliJ hint may not be the best ideaBestPractice
68.Streams● Benchmark use in performance critical sections● Parallel streams must be used with great care● Shared execution pool can be deceivingBestPractice
69.StreamsList<Trade> trades = loadTrades();Predicate<Trade> activePredicate = t -> t.isActive();Function<Trade, Money> valueFn = t -> presentValue(t);List<Money> valued =trades.stream().filter(activePredicate).map(valueFn).collect(Collectors.toList());TopTip● Extract lines if struggling to get to compile
70.StreamsList<Trade> trades = loadTrades();List<Money> valued =trades.stream().filter(t.isActive()).map((Trade t) -> presentValue(t)).collect(Collectors.toList());● Sometimes compiler needs a type hintTopTip
71.Streams● Learn to love 'Collector' interface● Complex, but useful● Sometime necessary to write them● Need collectors for Guava 'ImmutableList' and friends○ see 'Guavate' class in OpenGamma Strata
72.InterfacesI
73.Interfaces● Now have super-powers● Default methods○ normal method, but on an interface● Static methods○ normal static method, but on an interface● Extend interfaces without breaking compatibility● Cannot default equals/hashCode/toString
74.Interfaces● New macro-design options● Instead of factory class, use static method on interface● Instead of abstract class, use interface with defaults● Result tends to be fewer classes and better APITopTip
75.Interfaces● If factory method is static on interface● And all API methods are on interface● Can implementation class be package scoped?BestPractice
76.Coding Style● Use modifiers in interfaces● Much clearer now there are different types of method● Prepares for possible future with non-public methodsBestPracticepublic interface Foo {public static of(String key) { … }public abstract getKey();public default isActive() { … }}
77.Date and Time
78.Date and Time● New Date and Time API - JSR 310● Covers dates, times, instants, periods, durations● Brings 80%+ of Joda-Time to the JDK● Fixes the mistakes in Joda-Time
79.Date and TimeClass Date Time ZoneOffset ZoneId ExampleLocalDate ✔ ❌ ❌ ❌ 2015-12-03LocalTime ❌ ✔ ❌ ❌ 11:30LocalDateTime ✔ ✔ ❌ ❌ 2015-12-03T11:30OffsetDateTime ✔ ✔ ✔ ❌ 2015-12-03T11:30+01:00ZonedDateTime ✔ ✔ ✔ ✔ 2015-12-03T11:30+01:00[Europe/London]Instant ❌ ❌ ❌ ❌ 123456789 nanos from1970-01-01T00:00Z
80.Date and Time● Move away from Joda-Time● Avoid java.util.Date and java.util.Calendar● Use ThreeTen-Extra project if necessary○ http://www.threeten.org/threeten-extra/● Focus on four most useful types○ LocalDate, LocalTime, ZonedDateTime, Instant● Network formats like XML/JSON use offset types○ OffsetTime, OffsetDateTimeBestPractice
81.Date and Time● Temporal interfaces are low-level● Use concrete typesBestPractice// preferLocalDate date = LocalDate.of(2015, 10, 15);// avoidTemporal date = LocalDate.of(2015, 10, 15);
82.Rocket powered
83.Other features● Base64● Arithmetic without numeric overflow● Unsigned arithmetic● StampedLock● CompletableFuture● LongAdder/LongAccumulator● Enhanced control of OS processes
84.Other Features● Enhanced annotations● Reflection on method parameters● No PermGen in Hotspot JVM● Nashorn JavaScript● JavaFX is finally ready to replace Swing
85.Try a Java 8 open source library● JOOL○ https://github.com/jOOQ/jOOL● ThrowingLambdas○ https://github.com/fge/throwing-lambdas● Parts of OpenGamma Strata (strata-collect - Guavate)○ https://github.com/OpenGamma/Strata● But beware excessively functional ones○ most push ideas that don't really work well in Java
86.Immutability● Favour immutable classes● Lambdas and streams prefer this● Preparation for value types (Java 10?)● Use Joda-Beans to generate immutable "beans"○ http://www.joda.org/joda-beans/
87.SummaryJ8
88.Summary● Java 8 is great● Can be quite different to Java 7 and earlier● Vital to rethink coding style and standards○ methods on interfaces make a big difference● Beware the functional programming/Scala dudes○ a lot of their advice is simply not appropriate for Java