Refactoring to Java 8 (Devoxx BE)

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Ad

Trisha Gee (@trisha_gee)
Developer & Technical Advocate, JetBrains
Refactoring to
Java 8

Why Java 8?

It’s Faster
•Performance Improvements in Common Data
Structures
•Fork/Join Speed Improvements
•Changes to Support Concurre...

Easy to Parallelize

Fewer Lines of Code

New Solutions to Problems

Minimizes Errors

Safety Check

Test Coverage

Performance Tests

Decide on the Goals
•Readability
•Fewer lines of code
•Performance
•Learning

Limit the Scope

Morphia
https://github.com/mongodb/morphia

Refactoring to
Lambda Expressions

Automatic Refactoring
•Predicate
•Comparator
•Runnable
•etc…

Abstract classes

Performance of Lambda Expressions

Anonymous Inner Classes vs Lambdas
public String[] decodeWithAnonymousInnerClass(final BenchmarkState state) {
IterHelper....

0
20
40
60
80
100
120
140
160
180Ops/ms
Anonymous Inner Classes vs Lambdas
Anonymous Inner Class Lambda

http://www.oracle.com/technetwork/java/jvmls2013kuksen-2014088.pdf
0
2
4
6
8
10
12
14
16
18
20
single thread max threads
n...

Performance Analysis: Lambdas

Designing for Lambda Expressions

Performance of Lazy Evaluation

Logging Performance
public void loggingConstantMessage(BenchmarkState state) {
log("Logging");
}
public void loggingConsta...

0
50,000
100,000
150,000
200,000
250,000
300,000
350,000
400,000
450,000
500,000
Constant message Variable message
Ops/ms ...

Performance Analysis: Lazy Evaluation

Refactoring using
Collections & Streams

For loop to forEach()
…with and without Streams

EntityScanner– forEach()
public void mapAllClassesAnnotatedWithEntity (Morphia m) {
final Reflections r = new Reflections(...

0
0.01
0.02
0.03
0.04
0.05
0.06
Ops/ms
EntityScanner – forEach()
original refactored

DatastoreImpl – filter().flatMap().forEach()

0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
Ops/ms
DatastoreImpl
original refactored

DuplicatedAttributeNames – filter().map().forEach()

0
200
400
600
800
1000
1200
Ops/ms
DuplicatedAttributeNames
original refactored

Performance Analysis: forEach()

For loop to collect()

BasicDAO – map & collect
public List originalIterationCode() {
final List<Object> ids = new ArrayList<>(keys.size() * 2)
f...

0
1000
2000
3000
4000
5000
6000
7000
8000
9000
10000
Ops/s BasicDAO – map().collect() - 10 elements
original simplified re...

0
0.5
1
1.5
2
2.5
3
3.5
Ops/s BasicDAO – map().collect() - 10 000 element
original simplified refactored parallel

ReflectionUtils
public static List<Field> original(final Field[] fields, final boolean returnFinalFields) {
final List<Fie...

0
2000
4000
6000
8000
10000
12000
14000
AxisTitle ReflectionUtils – Arrays.stream().map().collect()
original refactored

Performance Analysis: collect()

Collapsing multiple operations

MappingValidator – single stream operation

0
1
2
3
4
5
6
7
8
9
10
EntityWithOneError EntityWith10Errors EntityWith20Errors
Ops/s Mapping Validator - multiple operati...

QueryImpl – multiple operations
public String[] retrieveKnownFields(org.mongodb.morphia.DatastoreImpl ds, Class clazz) {
f...

0
500
1000
1500
2000
2500
3000
3500
4000
Ops/s QueryImpl - multiple operations
original simplified refactored refactoredMo...

Performance Analysis: Multiple Operations

For loop to anyMatch()

TypeConverter – anyMatch()
protected boolean oneOfClasses(final Class f, final Class[] classes) {
for (final Class c : cla...

0
10000
20000
30000
40000
50000
60000
70000
Ops/s TypeConverter – anyMatch() – 10 Values
original refactored parallel

0
20
40
60
80
100
120
140
TypeConverter – anyMatch() – 10 000 Values
original refactored parallel

0
2
4
6
8
10
12
14
TypeConverter – anyMatch() – 100 000 Values
original refactored parallel

Performance Analysis: anyMatch()

Performance Analysis: Arrays.stream()

For loop to findFirst()

MapreduceType – IntStream().map().filter().findFirst()

0
5000
10000
15000
20000
25000
30000
AxisTitle MapreduceType - IntStream().map().filter().findFirst()
original refactored

Mapper – findFirst()
public static Class<? extends Annotation> original(final MappedField mf) {
Class<? extends Annotation...

0
5000
10000
15000
20000
25000
30000
35000
40000
45000
50000
Ops/s Mapper – Arrays.stream().filter().findFirst()
original ...

Converters – stream().findFirst()

0
1000
2000
3000
4000
5000
6000
7000
8000
9000
10000
Ops/s Converters - stream().filter().findFirst() – 10 Elements
origin...

0
0.5
1
1.5
2
2.5
3
3.5
Ops/s Converters – stream().filter().findFirst() – 10 000 elements
original refactored parallel

Performance Analysis: findFirst()

Use removeIf()

EntityScanner – removeIf()

0
10
20
30
40
50
60
Ops/s EntityScanner - removeIf()
original refactored

Performance Analysis: removeIf()

Summary of Findings

Refactoring to use lambda expressions is
easy to automate…

0
20
40
60
80
100
120
140
160
180
Ops/ms …and pretty safe performance-wise
Anonymous Inner Class Lambda

Designing for lambda expressions could
give a big performance benefit

0
50,000
100,000
150,000
200,000
250,000
300,000
350,000
400,000
450,000
500,000
Constant message Variable message
Ops/ms ...

Generally the new idioms increase
readability

Anonymous Inner Classes vs Lambdas

EntityScanner – forEach()

public List originalIterationCode() {
final List<Object> ids = new ArrayList<>(keys.size() * 2)
for (final Key<Object> key...

protected boolean oneOfClasses(final Class f, final Class[] classes) {
for (final Class c : classes) {
if (c.equals(f)) {
...

public static Class<? extends Annotation> original(final MappedField mf) {
Class<? extends Annotation> annType = null;
for...

EntityScanner – removeIf()

Particularly with multiple operations

MappingValidator – single stream operation

QueryImpl – multiple operations

But be aware of performance

Arrays.stream() is probably
substantially slower than using an array

0
10000
20000
30000
40000
50000
60000
70000
Ops/s TypeConverter - 10 Values
original refactored parallel

Using forEach() or collect() may be
slower than iterating over a collection

0
200
400
600
800
1000
1200
Ops/ms
DuplicatedAttributeNames
original refactored

Parallel is probably not going to give you
speed improvements
Unless your data is very big

0
0.5
1
1.5
2
2.5
3
3.5
Ops/s BasicDAO – map().collect() - 10 000 element
original simplified refactored parallel

Parallel is probably not going to give you
speed improvements
Or your operation is very expensive

But sometimes you get improved
readability and better performance

0
10
20
30
40
50
60
Ops/s EntityScanner - removeIf()
original refactored

Conclusion

Should you migrate your code to Java 8?

It Depends

Always remember what your goal is
And compare results to it

Understand what may impact performance
And if in doubt, measure

Your tools can help you
But you need to apply your brain too

http://bit.ly/refJ8
@trisha_gee

Share SlideShare

Facebook
Twitter
LinkedIn

Embed

Size (px)

Show related SlideShares at end

WordPress Shortcode

Link

LinkedIn
Facebook
Twitter
Email

Replay

Top clipped slide

1 of 100 Ad

1 of 100 Ad