Higher-Order Functions and Functional Composition

Higher-Order Functions and Functional Composition are concepts borrowed from functional programming paradigms and are supported primarily through Java 8’s lambda expressions and functional interfaces.

1. Higher-Order Functions in Java

A higher-order function is a function that:

• Takes one or more functions as arguments, or
• Returns a function as its result.

Java doesn’t have functions as first-class citizens like purely functional languages (e.g., Haskell), but using functional interfaces (like Function<T, R>, Predicate<T>, Consumer<T>, etc.), we can simulate this behavior.

Program :Higher-Order Functions

import java.util.function.Function;

public class HigherOrderExample {
    // A higher-order function: it takes a function as an argument
    static int applyFunction(int x, Function<Integer, Integer> func) {
        return func.apply(x);
    }

    public static void main(String[] args) {
        // Define a lambda function to square a number
        Function<Integer, Integer> square = num -> num * num;

        // Apply it using the higher-order function
        int result = applyFunction(5, square);
        System.out.println("Result: " + result); // Output: 25
    }
}

2. Functional Composition

Functional composition is the process of combining two or more functions to produce a new function. Java’s Function interface has two built-in methods for this:

• compose(Function before) – Executes the given function before the current function.
• andThen(Function after) – Executes the given function after the current function.

import java.util.function.Function;

public class FunctionalComposition {
    public static void main(String[] args) {
        Function<Integer, Integer> multiplyBy2 = x -> x * 2;
        Function<Integer, Integer> add3 = x -> x + 3;

        // Compose functions
        Function<Integer, Integer> composedFunction = multiplyBy2.andThen(add3);
        Function<Integer, Integer> composedFunction2 = multiplyBy2.compose(add3);

        System.out.println("andThen (x * 2 + 3): " + composedFunction.apply(5));   // Output: 13
        System.out.println("compose ((x + 3) * 2): " + composedFunction2.apply(5)); // Output: 16
    }
}

Why Use Higher-Order Functions and Composition?

• Encourages code reuse
• Enhances readability and modularity
• Helps in stream processing and pipeline creation (e.g., in Java Streams)
• Reduces side-effects, moving closer to functional purity

Practical Use Case:Unique Transformation with Vowel Masking

import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

public class PuzzleWithAll {
    public static void main(String[] args) {
        List<String> messages = Arrays.asList("paani", "mahesh", "raja", "sagar");

        // Raja's rule: convert to uppercase
        Function<String, String> rajasRule = String::toUpperCase;

        // Sagar's rule: replace vowels with '*'
        Function<String, String> sagarsRule = word -> word.replaceAll("[AEIOU]", "*");

        // Mahesh combines Raja's and Sagar's magic
        Function<String, String> maheshsMagic = rajasRule.andThen(sagarsRule);

        // Paani applies Mahesh's magic to all words
        List<String> transformed = messages.stream()
                                           .map(maheshsMagic)
                                           .collect(Collectors.toList());

        // Display results
        System.out.println("Mystical Transformation by Paani:");
        transformed.forEach(System.out::println);
    }
}
/*
Mystical Transformation by Paani:
P**N*
M*H*SH
R*J*
S*G*R
*/

Higher-order functions and functional composition are powerful programming concepts that bring functional programming capabilities into Java, especially with the introduction of lambda expressions and functional interfaces in Java 8.

• Higher-Order Functions are functions that can accept other functions as parameters or return them as results. This allows developers to write more abstract, reusable, and modular code.
• Functional Composition enables combining multiple functions to form a pipeline of operations. In Java, this is achieved using the Function interface’s compose() and andThen() methods.

By using these techniques:

• Code becomes cleaner and easier to test.
• Complex transformations can be broken into smaller, reusable units.
• Logic can be passed dynamically, improving flexibility and maintainability.

In Java, this functional style complements object-oriented programming and enhances expressiveness, particularly in stream processing, data transformation, and event handling.

Thus, mastering higher-order functions and functional composition allows Java developers to write concise, elegant, and modern applications using both functional and object-oriented paradigms effectively.