- Highlight the performance benefits of using Java 8 - after all, you’ll probably have to persuade "The Management" that tampering with existing code is worthwhile - Demonstrate how to identify areas of code that can be updated to use Java 8 features, and how to pick which changes will give you the most benefit - Demonstrate how to automatically refactor your code to make use of features like lambdas and streams - Cover some of the pros and cons of using the new features - including suggestions of when refactoring may NOT be the best idea.

1. @trisha_gee#DevoxxUK
Refactoring to Java 8
Trisha Gee, JetBrains
@trisha_gee
trishagee.com

2. Why Java 8?

3. It’s Faster
•Performance Improvements in Common Data
Structures
•Fork/Join Speed Improvements
•Changes to Support Concurrency
•…and more
http://bit.ly/refJ8

4. Easy to Parallelize

5. Fewer lines of code

6. Minimizes Errors

7. Safety Check

8. Test Coverage

9. Performance Tests

10. Decide on the Goals

11. Limit the Scope

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

13. Refactoring!

14. Lambda Expressions

15. Automatic Refactoring
•Predicate
•Comparator
•Runnable
•etc…

16. Abstract classes

17. Advanced Search

18. Collections & Streams

19. Automatic Refactoring
•For loop to collect
•For loop to forEach
•…with and without Streams

20. Manual Refactoring

21. Optional

23. But what about performance?

24. Lambdas

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

26. http://www.oracle.com/technetwork/java/jvmls2013kuksen-2014088.pdf
0
2
4
6
8
10
12
14
16
18
20
single thread max threads
nsec/op
Performance of Capture
anonymous(static) anonymous(non-static) lambda 


27. 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 Logging Performance
Lambda Direct call



28. Streams vs Iteration

29. 0
1
2
3
4
5
6
7
8
9
Ops/ms Iterator vs Stream
for loop forEach()



30. Going parallel

31. 0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
Serial Parallel
TimeTaken(seconds) map()
MacBook Surface



32. 0
20
40
60
80
100
120
140
160
Serial Parallel
TimeTaken(millis) findAny()
MacBook Surface



33. Optional

34. 0
50,000
100,000
150,000
200,000
250,000
300,000
350,000
Value not null Value null
Ops/ms Compare Constant Field Value with Null
Null check Optional



35. 0
50,000
100,000
150,000
200,000
250,000
300,000
Value not null Value null
Ops/ms Compare Variable Field Value with Null
Null check Optional



36. Summary

37. Sometimes new idioms decrease clutter

39. …but sometimes they don’t

41. Sometimes the new features improve
performance

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

43. …and sometimes they don’t

44. 0
50,000
100,000
150,000
200,000
250,000
300,000
Value not null Value null
Ops/ms Compare Variable Field Value with Null
Null check Optional

45. Sometimes a new feature makes life easier

47. …sometimes not so much

49. Some refactoring can safely be done
automatically

51. …often you need a human brain

53. Conclusion

54. Should you migrate your code to Java 8?

55. It Depends

56. Always remember what your goal is
And compare results to it

57. Understand what may impact performance
And if in doubt, measure

58. Code may magically improve
Or you may expose areas for improvement

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

60. http://bit.ly/refJ8
@trisha_gee