This document discusses ways to introduce functional programming concepts into Java code using existing Java 8 features, third-party libraries like Guava and LambdaJ, and by implementing common functional patterns and data structures yourself. It provides examples of using higher order functions, pure functions, recursion, and currying in Java code. It also summarizes capabilities of the Guava and LambdaJ libraries for functional programming in Java.

1. Poor man’s FP
How to change your java
code in a way you never
thought about

2. Dmitry Lebedev
• WILDCARD conf
• AIESEC/Lotus conf

3. Functional Programming
• Higher order functions
• Pure functions
• Recursion
• Non-strict evaluation
• Currying

4. Higher order functions
foo = Proc.new { |prompt| prompt.echo = false }
new_pass = ask("Enter your new password: ", &foo)

5. Pure Functions
foo = Proc.new { |x| x*x+(x+20) }

6. Recursion
def fib(n)
return n if (0..1).include? n
fib(n-1) + fib(n-2) if n > 1
end

7. Non-strict evaluation
print length([2+1, 3*2, 1/0, 5-4])

8. Currying
plus = lambda {|a,b| a + b}
plus.(3,5) #=> 8
plus_one = plus.curry.(1)
plus_one.(5) #=> 6
plus_one.(11) #=> 12

9. Java 8?
import java.awt.Button;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class Java8 {
public static void main(String[] args) {
Button myButton = new Button();
myButton.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent ae) {
System.out.println(ae.getSource());
}
});
}
}

10. Java 8?
import java.awt.Button;
import java.awt.event.ActionEvent;
public class Java8 {
public static void main(String[] args) {
Button myButton = new Button();
myButton.addActionListener((ActionEvent ae) -> {
System.out.println(ae.getSource());
});
}
}

11. Java 8?
import java.awt.Button;
public class Java8 {
public static void main(String[] args) {
Button myButton = new Button();
myButton.addActionListener(ae ->
{System.out.println(ae.getSource());}
);
}
}

12. Still living under Java 6?
Languages
• Scala
• Clojure
Libraries
• Guava
• LambdaJ
• Functional Java

13. Guava
• Function<A, B>, which has the single method B
apply(A input). Instances of Function are
generally expected to be referentially transparent -- no
side effects -- and to be consistent with equals, that
is, a.equals(b) implies that
function.apply(a).equals(function.app
ly(b)).
• Predicate<T>, which has the single method
boolean apply(T input). Instances of
Predicate are generally expected to be side-effect-free
and consistent with equals.

14. Guava
List converted = ImmutableList.copyOf(
Iterables.transform( userDTOs, new Function(){
public User apply( UserDTO input ){
return new User( input.name, input.id );
}
}));

15. LambdaJ
Person me = new Person("Mario", "Fusco", 35);
Person luca = new Person("Luca", "Marrocco", 29);
Person biagio = new Person("Biagio", "Beatrice", 39);
Person celestino = new Person("Celestino", "Bellone", 29);
List<Person> meAndMyFriends =
asList(me, luca, biagio, celestino);
List<Person> oldFriends =
filter(having(on(Person.class).getAge(), greaterThan(30)),
meAndMyFriends);

16. FunctionalJava
import fj.data.Array;
import static fj.data.Array.array;
import static fj.Show.arrayShow;
import static fj.Show.intShow;
import static fj.function.Integers.even;
public final class Array_filter {
public static void main(final String[] args) {
final Array<Integer> a = array(97, 44, 67, 3, 22, 90,
1, 77, 98, 1078, 6, 64, 6, 79, 42);
final Array<Integer> b = a.filter(even);
arrayShow(intShow).println(b);
// {44,22,90,98,1078,6,64,6,42}
}
}

17. Invention of Own Bicycle

18. First Attempt
public static <T> void forEach(Collection<T> list,
Procedure<T> proc) {
for (T object : list) {
proc.invoke(object);
}
}

19. Another try
public static <T, E> Collection<E> each(Collection<T>
list, Function<T, E> function) {
ArrayList<E> result = new ArrayList<E>();
for (T object : list) {
result.add(function.apply(object));
}
return result;
}

20. Use Case
result.addAll(
each(
imageList,
new Function<S3ObjectSummary, String>({
@Override
public String apply(@Nullable
S3ObjectSummary input) {
return siteURL + input.getKey();
}
}
));

21. Let’s complicate!
public interface MapFunction<T, K, V> {
Pair<K,V> proceed(T key);
}

22. Let’s complicate!
public static <T, K, V> Map<K, V>
map(Collection<T> list,
MapFunction<T, K, V> function) {
Map<K, V> result = new HashMap<K, V>();
for (T object : list) {
Pair<K, V> pair =
function.proceed(object);
result.put(pair.getKey(),
pair.getValue());
}
return result;
}

23. Let’s complicate!
...
List<Future> fs = new
ArrayList<Future>(list.size());
for (final T object : list) {
fs.add(exec.submit(new Callable() {
@Override
public Object call() throws Exception {
return function.proceed(object);
}
}));
}
...

24. Let’s complicate!
...
for (Future ft : fs) {
Pair<K, V> pair = (Pair<K, V>) ft.get();
result.put(pair.getKey(), pair.getValue());
}
...

25. Question?

26. The End