The principles of functional programming with applications in Java 8. Streams, Functions, Default Methods, Optional

1. FUNCTIONAL
PRINCIPLES
Introduction to Functional Programming
and Java 8

2. WHY ?

3. WHY FUNCTIONAL PROGRAMMING ? / MOORE’S LAW

4. WHY FUNCTIONAL PROGRAMMING ? / MULTI CORE TREND

5. WHY FUNCTIONAL PROGRAMMING ? / SOME HISTORY

6. WHAT ?

7. • A programming paradigm where
functions are first-class entities
• The main concepts are:
1. programming with functions
2. avoid mutation
• A new way of thinking
WHAT IS FP ?

8. • Object Immutability
• Functions:
– as first class citizens
– no side effects (Pure functions)
– Higher Order Functions
• No loops
• Lazy evaluation
WHAT IS FP ? / FUNCTIONAL PRINCIPLES

9. • Easier parallelization
• Less code
• Easy testing
• Results instead of steps
• Easy to understand code
WHAT IS FP ? / WHAT YOU GET ?

10. HOW ?

11. IMMUTABILITY

12. An immutable object is an object
whose state cannot be modified
after it is created
IMMUTABLE OBJECTS

13. “Classes should be immutable unless
there’s very good reason to make them
mutable… If a class cannot be made
immutable, limit its mutability as much
as possible”
Joshua Bloch
IMMUTABLE OBJECTS

14. IMMUTABLE OBJECTS / JAVA

15. IMMUTABLE OBJECTS / DEFENSIVE COPY

16. IMMUTABLE OBJECTS / OTHER FUNCTIONAL LANGUAGES

17. IMMUTABLE OBJECTS / OTHER FUNCTIONAL LANGUAGES

18. IMMUTABLE OBJECTS / HOW TO CHANGE ?

19. IMMUTABLE OBJECTS / PARALLELISM

20. •are thread-safe
•are simple to construct
•easy to test
•easy to use
•favors caching
IMMUTABLE OBJECTS / PROS

21. • Large object graphs
• Memory consumption
• Extra garbage collection cycles needed
IMMUTABLE OBJECTS / CONS

22. FUNCTIONS
F : X → Y

23. HIGHER ORDER
FUNCTIONS
(HOF)

24. HOF = functions that can take other
functions as arguments and / or
return other functions as result
HIGHER ORDER FUNCTIONS / DEFINITION

25. HIGHER ORDER FUNCTIONS / FIRST CLASS CITIZENS

26. HIGHER ORDER FUNCTIONS / FUNCTIONS AS PARAMS

27. HIGHER ORDER FUNCTIONS / RETURN FUNCTIONS

28. HIGHER ORDER FUNCTIONS / HOFS EXAMPLE IN F#

29. HIGHER ORDER FUNCTIONS / BENEFITS

30. •Allows easy parallelism
•Encourages abstraction
•Reusing of common code
•Isolates the essential parts
•Allows easier unit testing
HIGHER ORDER FUNCTIONS

31. HIGHER ORDER FUNCTIONS/ HOFS IN JAVA

32. HIGHER ORDER FUNCTIONS / JAVA CLASSES

33. HIGHER ORDER FUNCTIONS / USAGE OF JAVA 8 FUNC. CLS.

34. HIGHER ORDER FUNCTIONS

35. HIGHER ORDER FUNCTIONS / LAMBDA EXPRESSIONS
• A lambda expression is an anonymous
method
• Lambdas favor HOFs
• more powerful libraries
• more expressive, more readable, less
error-prone use code
• Boosts developer productivity
• key to an accessible parallelism strategy

36. HIGHER ORDER FUNCTIONS / LAMBDA EXAMPLES 1

37. HIGHER ORDER FUNCTIONS / LAMBDA EXAMPLES 2

38. HIGHER ORDER FUNCTIONS / HOF IN JAVA 8

39. HIGHER ORDER FUNCTIONS

40. HIGHER ORDER FUNCTIONS / FUNC. INTERFACE EXAMPLE

41. HIGHER ORDER FUNCTIONS / FUNCTION REFERENCES

42. CHECKPOINT

43. FUNCTIONS
(PURE
FUNCTIONS)

44. A function is said to be pure if
1. it returns same set of values
for same set of inputs
2. It does not have any
observable side effects
PURE FUNCTIONS / DEFINITION

45. PURE FUNCTIONS / EXAMPLE 1

46. PURE FUNCTIONS / EXAMPLE 2

47. Impure functions / Side effects :
1. Alter parameters passed by ref
2. Alter members of passed
objects
3. Alter external objects
PURE FUNCTIONS / SIDE EFFECTS

48. PURE FUNCTIONS / EXAMPLE 2

49. • sin(x)
• length(a)
• random()
• println(String s)
• Insert values(x, y, z) into DB_TABLE
PURE FUNCTIONS / SAMPLE OF PURE AND IMPURE FNC

50. • easier to understand
• easy maintenance
• easy testing / unit-testing
• favor concurrency
PURE FUNCTIONS / PROS

51. PURE FUNCTIONS / BENEFITS

52. “No side effects” is utopic
PURE FUNCTIONS / CONS

53. FUNCTION
COMPOSITION

54. FUNCTION COMPOSITION / MATH

55. FUNCTION COMPOSITION / SUPPORT IN JAVA 8

56. FUNCTION COMPOSITION / THE POWER OF COMPOSITION

57. CHECKPOINT

58. NO LOOPS

59. NO LOOPS / RECURSION

60. NO LOOPS
(RECURSION)

61. RECURSION / EXAMPLE OF AN ITERATIVE FUNCTION
A recursive function is a
function that calls itself
during its execution

62. RECURSION / RECURSIVE VS. ITERATION

63. RECURSION / TAIL RECURSION
Tail recursion = a recursive function
calls itself as its last action

64. NO LOOPS / RECURSION - TAIL RECURSION

65. NO LOOPS / RECURSION - TAIL RECURSION OPTIMIZATION

66. NO LOOPS / RECURSION - RECURSION ENCOURAGED

67. NO LOOPS
(FUNCTION
CHAINING)

68. NO LOOPS / FUNCTION CHAINING
• Similar to unix pipes :
ps -ax | tee processes.txt | more
• Already used in java in fluent interfaces
• Eliminate the need for intermediate variables

69. NO LOOPS / FUNCTION CHAINING
persons.stream()
.filter(e -> e.getGender() == Person.Sex.MALE)
.forEach(e -> System.out.println(e.getName()));
for (Person p : persons) {
if (p.getGender() == Person.Sex.MALE) {
System.out.println(p.getName());
}
}

70. NO LOOPS / AGGREGATE OPERATIONS
• They use internal iteration
• They process elements from a stream
• They support behavior as parameters

71. NO LOOPS / FUNCTION CHAINING EXAMPLE

72. NO LOOPS / FUNCTION CHAINING

73. NO LOOPS / FUNCTION CHAINING
double average = persons.stream()
.filter(p -> p.getGender() == Person.Sex.MALE)
.mapToInt(Person::getAge)
.average()
.getAsDouble();

74. FUNCTION CHAINING / DEFAULT METHODS

75. FUNCTION CHAINING / DEFAULT METHODS

76. FUNCTIONS CHAINING / STREAMS IN JAVA 8
• Streams do not provide a means to directly access or
manipulate their elements
• are concerned with declaratively describing the
computational operations which will be performed in
aggregate on that source
• No storage: they carry values from a source through a
pipeline
• Functional in nature ( operations do not modify its
underlying data)
• Operations can be implemented lazily ( for single pass
execution & efficient implementation of short-circuit
operations)
• No bounds : streams can be infinite

77. FUNCTION CHAINING / STREAMS, OPTIONAL, LAZINESS

78. FUNCTION CHAINING / SEQUENTIAL REDUCE

79. FUNCTION CHAINING / SEQUENTIAL REDUCE

80. FUNCTION CHAINING / PARALLEL STREAMS

81. FUNCTION CHAINING / PARALLEL REDUCE

82. PERFORMANCE OF PARALLEL PROCESSING

83. FUNCTION CHAINING / OTHER EXAMPLES

84. OTHER
FUNCTIONAL
FEATURES
(OPTIONAL)
Shameless copy-paste from
www.oracle.com/technetwork/articles/java/java8-optional-2175753.html

85. OPTIONAL / WHY OPTIONAL ?

86. OPTIONAL / NULL, THE BILLION DOLLAR MISTAKE
"I call it my billion-dollar mistake. It was the invention of the
null reference in 1965. […]
I couldn't resist the temptation to put in a null reference,
simply because it was so easy to implement.
This has led to innumerable errors, vulnerabilities, and system
crashes, which have probably caused a billion dollars of pain
and damage in the last forty years“
Tony Hoare

87. OPTIONAL / THE SOLUTION TO NULL
java.util.Optional<T> :
• A class that encapsulates an optional value
• A single-value container that either contains
a value or doesn't (empty)

88. OPTIONAL / HOW TO CREATE IT

89. OPTIONAL / HOW TO USE IT

90. OPTIONAL / THE MOST IMPORTANT METHODS

91. OPTIONAL / RETURN TO ORIGINAL EXAMPLE

92. OPTIONAL / BENEFITS
• Idiot proof / Clear intent
• Cleaner code (no more null checks)
• Encourages method chaining
• End of NullPointerException

93. OPTIONAL / CONS
• Performance
• Serialization - Optional is not
• Certain operations involving
parametric polymorphism become
cumbersome

94. CHECKPOINT

95. FP CHANGES
EVERYTHING

96. EVERYTHING CHANGES / THREADS WITH LAMBDAS

97. EVERYTHING CHANGES / ACTION LISTENERS W/ LAMBDAS

98. EVERYTHING CHANGES / COMPARATORS

99. EVERYTHING CHANGES / LIST ITERATION, FILTERING, ETC.

100. EVERYTHING CHANGES / READING FILES

101. EVERYTHING CHANGES / SPRING

102. CHECKPOINT

103. • Immutability
• Higher Order Functions
• Pure functions
• No loops ( recursion, function chaining)
• Lazy evaluation
• Type inference
• Parallelism
• Easy coding / understanding
RECAP / FUNCTIONAL PROGRAMMING

104. • Introduced FP features
• Functional interfaces
• Function/Predicate/Producer/Consumer
• Default methods
• Lambda expressions
• Streams
• Map/Reduce/Filter/Collect
• Type inference
RECAP / JAVA 8

105. • Easier parallelization
• Less code
• Easy testing
• Results instead of steps
• Easy to understand code
WHAT IS FP ? / WHAT YOU GET ?

106. QUESTIONS

107. THE END

108. • Scheme, Lisp
• ML, OCaml
• Haskell
• Erlang
• Scala
• Clojure
• F#
WHAT’S NEXT ? / OTHER FUNCTIONAL LANGUAGES

109. •Retrolambda – backport of
java 8 lambdas in Java 7,6,5
•functionaljava.org
•Google Guava
WHAT’S NEXT ? / FP IN JAVA BEFORE JAVA8

110. •Reactive programming
WHAT’S NEXT ? / OTHER TECHNOLOGIES

111. WHAT’S/WHO’S
NEXT ?