Java Functional Programming

Why?

• Functional Programming is a programming paradigm for developing and solving software problems in terms of functions and immutable values that translate between them.

• This means that these functions and values have:

  • no state

  • no side effects

  • are immutable variables

  • favour recursion (iteration?) over looping

public class ObjectWithPureFunction{

  public int sum(int a, int b) {
    return a + b;
  }
}

The example given above is of a pure function, whose output sum() only depends on its input parameters.

How?

• Functional Programming facilitates the reuse of common utility functions to process data more efficiently.

• It takes advantage of the ability to represent a function as a value that can be put into a variable.

• This is unlike Object Oriented Programming, where methods and data are together. Here, we’re only interested in the function / method. Which is also the reason why we define the method with a functional interface, because an interface focuses on a method interface and not its implementation or state.

• These characteristics are helpful for creating common utility functions (like macros) that can act on many different data types.

• Because it has no state, no side effects and use immutable variables, we can create high order functions that take other such functions as arguments, or return functions.

• High Order Functions give us the possibility of chaining such utility functions together, allowing us to write succinct code that gets us to the heart of what we want to do.

• For this purpose, Lambda Expressions were introduced in Java 8. Lambda Expressions are used to pass a block of code to another method or object.

• It greatly simplifies the syntax used to define inner classes and anonymous classes, making it more natural for developers to use functional programming instead.

• Functional Interfaces serve as a data type for Lambda Expressions, because a functional interface contains only one abstract method, removing the ambiguity about which method would be used.

Examples (What?)

Given below are some very basic operations commonly used in functional programming:

collect()

This is a terminal method with an eager operation that generates a list from values in a stream. It provides options for packaging, such as concatenation, toList, toMap, toSet, etc.

List<String> collected = Stream.of("a", "b", "c")
                            .collect(Collectors.toList());
assertEquals(Arrays.asList("a", "b", "c"), collected);

• Line 1 starts by getting a Stream from a List.

• Line 2 creates a new list.

• Line 3 asserts that the lists are equal (have the same content).

String[] input = {"tiger", "cat", "TIGER", "Tiger", "leopard"};
List<String> cats = Arrays.asList(input);
String search = "tiger";
String tigers = cats.stream()
                  .filter(s -> s.equalsIgnoreCase(search))
                  .collect(Collectors.joining(", "));
System.out.println(tigers);

Some of the collectors avalable are toList(), toSet(), toMap(), collectingAndThen(), joining(), counting(), summarizingDouble/Long/Int(), averagingDouble/Long/Int(), summingDouble/Long/Int(), maxBy(), minBy(), groupingBy(), partitioningBy() and teeing().

map()

This function processes each element in a list or list-like container, performs an operation on each element, and creates a new list.

List<String> collected = new ArrayList<>();
for (String theString : asList("a", "b", "hello")) {
  String upperCaseString = theString.toUpperCase();
  collected.add(upperCaseString);
}
assertEquals(asList("A", "B", "HELLO"), collected);

filter()

This function processes each element, eliminating elements that do not meet a user defined selection criteria and creates a new (smaller) list.

long count = allArtists.stream().filter(artists -> {
  return artist.isFrom("London");
})

reduce()

This function usually takes two parameters - an initial value and an aggregation or reduction function (such as sum()), and applies that function to each element in turn, building up a final result from the whole list or collection.

int sum = Stream.of(1,2,3).reduce(10, (acc, element) -> acc + element);
assertEquals(16, sum);

foreach()

List<String> pets = Arrays.asList("dog", "cat", "fish", "iguana", "ferret");
pets.stream().forEach(System.out::println);

Note

• From the examples above, it can be seen that, in functional programming, it is usual to create a new list or collection, rather than modifying an existing one in-place.

• With collections, the The Java Streams API abstraction is what really brings out the benefits of functional programming.

• Java collections are imperative and not functional. Hence, they need to be converted to streams before functional programming can be used.

• With The Java Streams API, Java brings about Functional Programming as another tool for developers.

Lexical Scoping & Class Instance from an Interface

public class sol_101a {
    public interface IntHolder {
        int getValue();
    }

    public static void Solution101() {
        System.out.println("Solution101 --> Entered function.");
        // Java allows us to create an IntHolder class from an interface
        IntHolder[] holders = new IntHolder[10];

        for (int i = 0; i < holders.length; i++) {
            final int fi = i + 100;
            // this statement below will not work
            // holders[i] = fi;
            holders[i] = () -> fi;
        }

        for (IntHolder i:holders) {
            System.out.println("sol_101a::Solution101 --> holders[] = " + i.getValue());
        }
    }
}

The example above shows a few things based on Functional Programming:

• The ability to create an instance of a class from an interface, without having to use the “implements” keyword.

• The local temporary variable fi (line 12), is technically confined in scope to its curly brackets in the for loop. However, the lambda expression in line 15 has the ability to break this assumption, because the lambda expression makes a copy of fi, which is what lambda expressions usually do.

The output for the code shown above will result in: .. code-block:

sol_101a::Solution101 --> holders[] = 100
sol_101a::Solution101 --> holders[] = 101
sol_101a::Solution101 --> holders[] = 102
sol_101a::Solution101 --> holders[] = 103
sol_101a::Solution101 --> holders[] = 104
sol_101a::Solution101 --> holders[] = 105
sol_101a::Solution101 --> holders[] = 106
sol_101a::Solution101 --> holders[] = 107
sol_101a::Solution101 --> holders[] = 108
sol_101a::Solution101 --> holders[] = 109