Java Functional Programing in short

 

All of us are very well aware of the Object Oriented Programing OOP, which usually use for loops, whiles, switches, if ...etc to solve a problem.

For example, we have list of lists and we want to merge it in one list, the standard imperative way is to initiate empty list then loop to fill it as the following:-

private static final List<List<String>> arrayListOfNames = List.of(

        List.of("Mariam", "Alex", "Ismail"),

        List.of("John", "Alesha", "Andre"),

        List.of("Susy", "Ali"));

List<String> flatList = new ArrayList<>();

for (List<String> names : arrayListOfNames) {

    for (String name : names) {

        flatList.add(name);

    }

}

This called imperative.

 

Function takes input and gives you output and it must not depends on anything outside the function NO STATE

 

With OOP you setup classes and you make instances from theses classes OBJECTS.

Lets take a quick example of sending email via gmail and sending email via hotmail 

we will create Interface called SendingEmail just void interface doing nothing 

we will create two classes one called Hotmail and other one is Gmail, both implement the SendingEmail interface with send method

so at the main class simply to send email to gmail or hotmail you will do the following 

SendingEmail gmail = new Gmail() // new instance of the interface and its implementation 

gmail.send() // to call and implement 

@FunctionalInterface

The idea is that functional programming using lambdas, and lambdas used for interfaces with one abstract methods!

So if the interface include more than one abstract method it won't work
Abstract method has to be implemented when you implement the interface.

EmailSender Interface has abstract method called send()

gmail class has to has the send method send() {logic} to implement the gmail logic 

if the interface has one abstract method we will call the abstract this way

SendingEmail gmail = new Gmail() // new instance of the interface and its implementation 

gmail.send() // to call and implement 

BUT since the interface has only one abstract method we can use concise way called lambda which implement the abstract directly inline 

SendingEmail gmail = () -> {logic for example sout strings}

gmail.send() // to call and implement 

This is a better concise way

but REMEMBER that the interface has one abstract method 

For that reason the definition of lambda is 

"" is a concise way to represent a method interface using an expression. Lambda expressions are commonly used to define inline implementation of a functional interface, i.e., an interface with a single abstract method.""

and easy to guess if the abstract method takes parameter you can pass it to lambda 

(parameters) -> expression

so @FunctionalInterface is decoration to tell whoever read the interface it has to be one abstract method ONLY other wise you won't be able to use lambda!

Example 1 

@FunctionalInterface
interface MyFunction {
    int apply(int a, int b);
}
// Functional interface has one abstract method apply() which you have to implement 

MyFunction add = (a, b) -> a + b;

int result = add.apply(5, 3); // result is 8

and if apply has one argument you can use it without () even

of course result has to be int since apply method return int

Method references 

 

You can use a method reference when a lambda expression is doing nothing but calling an existing method.

 

Example 

 

@FunctionalInterface
interface Adder {
    int add(int a, int b);
}

public class Calculator {

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

    public static void main(String[] args) {
        // Using a method reference to refer to the static add method
        Adder addFunction = Calculator::add;
        
        int result = addFunction.add(10, 20);
        System.out.println("The sum of 10 and 20 is " + result); // Output: The sum of 10 and 20 is 30
    }
}

and this was the case with normal lambda expression 

// Using a lambda expression to call the static add method
        Adder addFunction = (a, b) -> Calculator.add(a, b);

java.util.function

This package it has a lot of interfaces in a type where it has single abstract method (Functional Method) SO it is kind of interfaces which target the usage of Lambda Expression and Method references.

So rather you created the function interface yourself to output specific kind of operations or data, these interfaces come to help and save your time 

Example 

Function Interface

import java.util.function.Function;

public class FunctionalApproach {
    public static void main(String[] args) {

        // Function interface takes one input along with its type and using lambda inline you can    //implement whatever operation
        Function<Integer, Integer> doubleNumber = x -> x * 2;
        
        int number = 5;
        int result = doubleNumber.apply(number);
        
        System.out.println("Using Function Interface: " + result); // Output: Using Function Interface: 10

        // if using oop you have ti implement static method 

        public static int doubleNumber(int number) {
        return number * 2;
    }

    // so it been replaced by inline lambda expression
        
    }
}
 

There are a lot of interfaces, Function, Consumer, BiConsumer, Predicate 

Each it accept type of data and it could output or not

 

So in brief 

Function in oop is something you may pass something and it could output something or not, the way you coded 
Functional interfaces it do the same but in shorter code it allow you to use lambda expressions 

interfaces saved the time and concise code

Many Many types if interfaces 

 

 

Examples 

 

 

import java.util.function.Consumer;
import java.util.function.BiConsumer;
import java.util.function.Predicate;
import java.util.function.BiPredicate;
import java.util.function.Supplier;

public class FunctionalInterfacesExample {

    // OOP Method to print a string
    public static void printStringOOP(String str) {
        System.out.println(str);
    }

    // OOP Method to add two numbers
    public static void addNumbersOOP(int a, int b) {
        System.out.println(a + b);
    }

    // OOP Method to check if a number is even
    public static boolean isEvenOOP(int number) {
        return number % 2 == 0;
    }

    // OOP Method to check if two strings have the same length
    public static boolean sameLengthOOP(String str1, String str2) {
        return str1.length() == str2.length();
    }

    // OOP Method to provide a greeting message
    public static String getGreetingOOP() {
        return "Hello, World!";
    }

    public static void main(String[] args) {
        // Using Consumer to print a string
        Consumer<String> printString = str -> System.out.println(str);
        printString.accept("Using Consumer"); // Output: Using Consumer
        printStringOOP("Using OOP"); // Output: Using OOP

        // Using BiConsumer to add two numbers
        BiConsumer<Integer, Integer> addNumbers = (a, b) -> System.out.println(a + b);
        addNumbers.accept(5, 10); // Output: 15
        addNumbersOOP(5, 10); // Output: 15

        // Using Predicate to check if a number is even
        Predicate<Integer> isEven = number -> number % 2 == 0;
        System.out.println(isEven.test(4)); // Output: true
        System.out.println(isEvenOOP(4)); // Output: true

        // Using BiPredicate to check if two strings have the same length
        BiPredicate<String, String> sameLength = (str1, str2) -> str1.length() == str2.length();
        System.out.println(sameLength.test("apple", "peach")); // Output: true
        System.out.println(sameLengthOOP("apple", "peach")); // Output: true

        // Using Supplier to provide a greeting message
        Supplier<String> getGreeting = () -> "Hello, World!";
        System.out.println(getGreeting.get()); // Output: Hello, World!
        System.out.println(getGreetingOOP()); // Output: Hello, World!
    }
}
 

 

Consumer and BiConsumer are used to represent operations that take one and two parameters, respectively, and return no result.

Predicate and BiPredicate are used to represent Boolean-valued functions that take one and two parameters, respectively.

Supplier is used to represent an operation that takes no input and returns a value.
Corresponding OOP methods are included to perform the same operations, demonstrating how each functional interface can be used as an alternative to traditional method calls.