DEV Community: salmanetamo

Functional Programming in Java

salmanetamo — Fri, 10 Jun 2022 18:04:47 +0000

This will be a quick intro to Functional Programming in Java. In order to understand this tutorial, you should be familiar with the basics of writing code in Java. If you want to follow along and try some of the code, you may use your favorite IDE; I personally use IntelliJ.

What is Functional Programming in Java?

Simply put, Functional Programming is a style of programming that leverages functions. You can think of these functions as simple mathematical functions like f(x) = x + 2.

Function<Integer, Integer> f = x -> x + 2;
System.out.println(f.apply(4));  // Prints 6

A very common description of Java is that it is an Object Oriented Programming language, and any Java developers should be comfortable with OOP constructs such as classes and objects. In Functional Programming, focus is less about objects and more about the functions.

The predictability nature of Functional Programming allows us to write code that is more easily testable and with no desired side effects. This is because the functions, in Functional Programming, are pure(they always return the same output for a given input) and enable immutability and referential transparency.

How to use Functional Programming in Java?

In Java, Functional Programming is enabled through the usage of Lambdas, which were introduced in Java 8. Lambdas are implementations on functional interfaces(interface with a single abstract method), and are really the ones that play the role of the “functions” in Functional Programming. They can be assigned to variables, can be passed as parameters to other functions or can even be returned from other functions.

Why do we need Functional Programming in Java?

There are several reasons why we should care about Functional Programming as we strive to write concise, readable and efficient code.

Lazy evaluation: With lazy evaluation, an expression is only executed when its value is needed, which both saves time and keeps us from doing the same computation multiple times. See the output of the example below to illustrate this

var numbers = List.of(5, 2, 7, 8);
Stream<Integer> numbersPlusTwo = numbers.stream().map(number -> {
    System.out.println("Printing number: " + number);
    return number + 2;
});
System.out.println("I get printed first");
System.out.println("Numbers plus two: " + numbersPlusTwo.collect(Collectors.toList()));

The output:

// I get printed first
// Printing number: 5
// Printing number: 2
// Printing number: 7
// Printing number: 8
// Numbers plus two: [7, 4, 9, 10]

Immutability: Functions in Functional Programming do not modify state, and only act on the inputs they are provided. This avoids unexpected behavior and makes it easier to debug the code.
Readability and Conciseness: With Functional Programming, we write much more concise code, which is generally more readable.

This was a brief look at Functional Programming in Java, its usage, and its advantages. With functions being treated as “first-class citizens”, we get to achieve a lot and more efficiently in Java. Functional Programming is not meant to oppose Object Oriented Programming but really augments it, and combining them together in your programs is the more obvious way to go.

Exploring Lambdas in Java

salmanetamo — Sun, 05 Jun 2022 10:33:47 +0000

This will be a quick intro to Lambdas in Java. In order to understand this tutorial, you should be familiar with the basics of writing code in Java. If you want to follow along and try some of the code, you may use your favorite IDE; I personally use IntelliJ.

What are lambda expressions?

The simplest way to think about a lambda expression is that it is an anonymous or unnamed method that doesn’t necessarily belong to any class.
Lambdas were introduced in Java 8 and provide us with ways to use functional programming to write more precise and powerful code in Java.

Before going any further with lambdas, we need to learn about functional interfaces. This is because lambda expressions are implementations of functional interfaces.
A functional interface is an interface with one and only one abstract method.

@FunctionalInterface
public interface CanSwim {
    void swim();
}

Note the @FunctionalInterface annotation added to the interface. This is not required for the definition of the functional interface, but it guarantees that no other abstract methods are added to the interface.

There are many existing functional interfaces that you can explore in the java.util.function package. They cover most of the use cases for using functional interfaces and as such, you may not have to create many of these yourself.

Now, back to lambdas. The way they relate to functional interfaces is that they are an implementation of that single abstract method of the functional interface. Here’s how that looks like based on our previous example.

CanSwim fish = () -> System.out.println("I'm a fish and I'm swimming!");
fish.swim(); // Prints "I'm a fish and I'm swimming!"

How do you create and use lambda expressions?

The general structure of a lambda expression is as follows.

(parameter list) -> {lambda body}

Lambda expressions are supposed to be concise in nature. With that in mind, here are a few considerations regarding the structure above:

Parameter list: This list can have 0, 1 or more parameters. The parentheses are mandatory except when there is a single parameter and if the type of the variable can be inferred from the context.
The arrow: The arrow is called the arrow operator or lambda operator and is always required
The lambda body: The curly braces around the lambda body are optional if the operation can be evaluated in a single expression. For more complex operation (declaring variables, using loops, using if statements, etc), the curly braces are required. The keyword return is only required in the lambda body if curly braces are used and a return value is expected.

Here are a few examples using some of the interfaces in the java.util.function package:

// Takes a single integer and has a void return type
IntConsumer printInteger = x -> System.out.println(x);
printInteger.accept(4); // Prints "4"

// Takes 2 integers and returns a string
BiFunction<Integer, Integer, String> joinNumbers = (number1, number2) -> number1 + ", " + number2;
System.out.println(joinNumbers.apply(3, 4));; // Prints "3, 4"

// Takes two Strings and returns a string
BinaryOperator<String> concatenateWords = (String word1, String word2) -> word1 + " " + word2 + "!";
System.out.println(concatenateWords.apply("Hello", "World")); // Prints "Hello World!"

// Takes an integer and returns a string
Function<Integer, String> getFizzBuzzText = number -> {
    if (((number % 5) == 0) && ((number % 7) == 0))
        return "fizzbuzz";
    else if ((number % 5) == 0)
        return "fizz";
    else if ((number % 7) == 0)
        return "buzz";
    else
        return "" + number;
};
System.out.println(getFizzBuzzText.apply(35));  // Prints "fizzbuzz"

Why should we care about lambda expressions?

The power of lambda expressions resides in the fact that they allow functions to be passed around the same way you would for method parameters. As such, it is a great enabler for functional style programming, where functions or code can also be treated as “data”.

Lambdas become even more powerful when coupled with Java Streams introduced in Java 8 allowing us to perform complex operations on collections.

This was a brief overview of Lambdas in Java. We discussed how they are implementations of functional interfaces and how they could be used. Most Lambda expressions you will write will probably implementations of the built-in functional interfaces so I recommend familiarizing yourself with those.

Exploring Java Streams

salmanetamo — Mon, 23 May 2022 17:44:50 +0000

In order to understand this tutorial, you should be familiar with the basics of writing code in Java. If you want to follow along and try some of the code, you may use your favorite IDE; I personally use IntelliJ.

What are streams?

A Stream in Java is essentially a sequence of elements from a given data source (an array or Collection). The Stream does not store the data but rather acts a pipeline that allows us to perform some operations on that data.

Those such operations are of two types: intermediate and terminal. Intermediate operations always return a Stream thus allowing us to keep chaining multiple intermediate operations; the most common ones being map() and filter(). Terminal operations, however, return either void or some other return type and, as the name suggests, terminate the pipelining. The most common terminal operation is forEach().

How do we create streams?

There are a multiple ways to create a Stream.

The most common of these is probably using the stream() method from the Collection Interface for collections and from the Arrays class for arrays.

// Stream from a list
List<Integer> numList = List.of(3, 56, 7, 6);
Stream<Integer> numListStream = numList.stream();


// Stream from an array
Integer[] numArray = new Integer[]{3, 56, 7, 6};
Stream<Integer> numArrayStream = Arrays.stream(numArray);

You can also create a Stream using Stream.of() which takes in the elements in the stream as a parameter.

Stream<Integer> numbersStream = Stream.of(3, 56, 7, 6);

Another way to create Streams is by using Stream.generate() or Stream.iterate(). Note that these two methods create infinite streams so always make sure to limit the number of elements to be part of the streams through the limit() method. These methods both take a Supplier as a parameter in order to generate the elements. The Stream.iterate() method additionally takes an initial element as parameter, also used to generate subsequent elements.

Stream<String> stringStream = Stream.generate(() -> "Streams are cool").limit(10);
// Print "Streams are cool" 10 times
stringStream.forEach(System.out::println);

Stream<Integer> multiplesOfThreeStream = Stream.iterate(3, num -> num + 3).limit(10);
// Print the first 10 multiples of 3
multiplesOfThreeStream.forEach(System.out::println);

For the primitive types int, long, and double, you can also use the following three special interfaces respectively to create Streams for those types: IntStream, LongStream, and DoubleStream. These come with some handy methods that enables the creation of ordered streams with values within a given range namely the range() and rangeClosed() methods.

IntStream intStream = IntStream.of(3, 56, 7, 6);
LongStream longStream = LongStream.of(3L, 56L, 7L);
DoubleStream doubleStream = DoubleStream.of(3.2, 5.6, 7.0);

IntStream intStreamRange = IntStream.range(1, 11);
// Print 1 2 3 4 5 6 7 8 9 10
intStreamRange.forEach(System.out::println);

IntStream intStreamRangeClosed = IntStream.rangeClosed(1, 10);
// Print 1 2 3 4 5 6 7 8 9 10
intStreamRangeClosed.forEach(System.out::println);

What’s the big deal about streams anyway?

One of the biggest advantage of Streams is that it allows us to move from imperative programming to declarative programming. In Java, this is achieved through the usage of Functional style programming, that leverages Lambdas leading to powerful and more concise code.

Let’s illustrate this with an example. Imagine you have a list of strings on which you wish to do the following:

Sort the list alphabetically
Remove duplicates
Capitalize all the letters
Keep strings ending with letter “x”
Print to the console

The list:

List<String> words = new ArrayList<>(List.of("track", "enfix", "spell", "complex","impulse", "comedy", "magnetic", "complex", "witch", "plead", "spell", "thesis", "thesis"));

In an imperative approach here’s how you might go about it:

Collections.sort(words);
Set<String> wordsWithoutDuplicates = new LinkedHashSet<>(words);
for(String word : wordsWithoutDuplicates) {
    if (word.endsWith("x")) {
        String wordCapitalized = word.toUpperCase();
        System.out.println(wordCapitalized);
    }
}

With a declarative approach, here’s a potential solution. Notice how much cleaner the code is.

words.stream()
        .sorted()
        .distinct()
        .filter(word -> word.endsWith("x"))
        .map(String::toUpperCase)
        .forEach(System.out::println);

This was a very brief overview of Streams, that were introduced in Java 8, which provide us with powerful means to manipulate data.