Why Functional Programming Matters

For years, object oriented programming has been the default paradigm in enterprise software. Encapsulation, polymorphism, and inheritance have provided structure to complex applications, allowing teams to build maintainable systems at scale. However, as distributed computing, concurrency, and reactive systems become more critical, functional programming offers a powerful complement to OOP.

Managing mutable state in large applications introduces hidden dependencies, race conditions, and side effects, making debugging and scaling a nightmare. Functional programming minimizes these risks by emphasizing pure functions, immutability, and composition, leading to predictable and testable code.

This article explores how Functional Programming principles can make Java applications more efficient, scalable, and maintainable.

---

OOP vs Functional Programming: Different Paths to the Same Goal

Object oriented programming solves complexity by encapsulating state inside objects and exposing controlled behaviors through methods. Functional programming, on the other hand, models computation as data transformation pipelines that take inputs and produce outputs with no side effects.

Let’s illustrate the difference with a simple example: converting a list of temperatures from Celsius to Fahrenheit.

Object Oriented Approach:

import java.util.List;

class TemperatureConverter {

  double celsiusToFahrenheit(double celsius) {
    return celsius * 9.0 / 5.0 + 32.0;
  }

  List<Double> convertAll(List<Double> celsiusList) {
    return celsiusList.stream()
        .map(this::celsiusToFahrenheit)
        .toList();
  }
}

This approach encapsulates behavior ina class but doesn’t eliminate mutable state or side effects.

Functional Approach:

import java.util.List;

public class FunctionalTemperatureConverter {

  public static List<Double> convertAll(List<Double> celsiusList) {
    return celsiusList.stream()
        .map(c -> c * 9.0 / 5.0 + 32.0)
        .toList();
  }
}

Key Differences:

• No need to instantiate a class, pure function does the work.
• No side effects, just data transformation.
• Better readability and testability.

---

Function Composition: The Power of Chaining

One of Functional Programming’s most valuable features is function composition, where small, reusable functions are combined to create complex behavior.

Before: Nested Calls in OOP

String result = formatData(enrichData(fetchData()));

Nested calls reduce readability and make debugging harder.

After: Function Composition

import java.util.function.UnaryOperator;

UnaryOperator<String> fetchData = data -> "Fetched: " + data;
    UnaryOperator<String> enrichData = data -> data + " | Enriched";
    UnaryOperator<String> formatData = String::toUpperCase;

    UnaryOperator<String> pipeline = fetchData
        .andThen(enrichData)
        .andThen(formatData)::apply;

    String result = pipeline.apply("User123");

Why It Works:

• Functions are composed in a logical sequence.
• Readability improves, left to right execution mirrors the data flow.
• Debugging is easier because intermediate steps can be logged or tested separately.

---

Functional Dependency Injection: Avoiding Hidden State

Managing dependencies without relying on global state or singletons is a hallmark of Functional Programming.

Traditional Approach: Injecting Dependencies via Constructor

public class UserService {

  private final UserRepository userRepository;

  public UserService(UserRepository userRepository) {
    this.userRepository = userRepository;
  }

  public User getUserById(String id) {
    return userRepository.findById(id);
  }
}

While this approach is better than using a global singleton, it still binds the class to a specific implementation.

Functional Approach: Passing Dependencies as Functions

import java.util.function.Function;

public class UserService {

  Function<String, User> fetchUser = id -> new User(id, "Adrian M");

  User user = fetchUser.apply("123");
}

Advantages:

• Functions become first class citizens, reducing class dependencies.
• Code is more flexible and testable, any function matching Function<String, User> can be passed.

---

Functional Web API with Java 21

Let’s apply Functional Programming concepts to build a simple web request handler in Java 21 using Virtual Threads for scalability.

Declarative HTTP Endpoint

import com.sun.net.httpserver.HttpServer;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetSocketAddress;
import java.util.Optional;
import java.util.function.Function;

HttpServer server = HttpServer.create(new InetSocketAddress(8080), 0);

    Function<String, String> getUserPage = userId -> "User Page for: " + Optional.ofNullable(userId)
        .orElse("Unknown");

    server.createContext("/user", exchange -> {
      try (exchange) {
        String query = exchange.getRequestURI().getQuery();
        String response = getUserPage.apply(query);

        exchange.sendResponseHeaders(200, response.length());
        try (OutputStream os = exchange.getResponseBody()) {
          os.write(response.getBytes());
        }
      } catch (IOException e) {
        e.printStackTrace();
      }
    });

    server.setExecutor(null);
    server.start();

    System.out.println("Server started on port 8080...");

Functional Request Processing

Function<String, String> getUserPage = id -> fetchUser
        .andThen(userToHtml)
        .apply(id);

---

Conclusion: Functional Thinking for Better Java

At the end of the day, functional programming isn’t about replacing OOP, it’s about enhancing the way we write software. If there’s one thing I’ve learned over the years, it’s that the fewer surprises in your code, the better. Functional programming gives you that: predictability, readability, and scalability.

If you’re building Java applications today, embracing functional programming isn’t just an option, it’s a smart evolution.