Java supports the concept of functional programming, which can be achieved by 1. Using functional interfaces and lambda expressions to implement first-class and higher-order functions; 2. Using immutable objects and pure functions to implement immutability and pure functions; 3. Using Stream API for declarative data processing; 4. Using Function andThen and compose methods to realize function combinations; 5. Avoid side effects and prioritize expressions over statements, so as to write clearer, predictable and easy to test code.

Java may not be a purely functional language, but it has embedded many functional programming (FP) concepts since Java 8. These concepts help write cleaner, more predictable, and easier-to-test code. Here's a breakdown of the key functional programming ideas available in Java and how to use them effectively.

1. First-Class and Higher-Order Functions via Functional Interfaces

In functional programming, functions are treated as first-class citizens — meaning they can be passed as arguments, returned from other functions, and assigned to variables.

In Java, this is achieved using functional interfaces (interfaces with exactly one abstract method) and lambda expressions .

Example:

 @FunctionalInterface
interface MathOperation {
    int apply(int a, int b);
}

public class Example {
    public static void main(String[] args) {
        MathOperation add = (a, b) -> ab;
        MathOperation multiply = (a, b) -> a * b;

        System.out.println(add.apply(5, 3)); // 8
        System.out.println(multiply.apply(5, 3)); // 15
    }
}

Java provides built-in functional interfaces in java.util.function :

• Function<T, R> – take one argument and returns a result
• Predicate<T> – returns a boolean (useful for filtering)
• Consumer<T> – take input but returns nothing (side effects)
• Supplier<T> – take no input, returns a value
• UnaryOperator<T> , BinaryOperator<T> – for operations on single or two values of the same type

2. Immutability and Pure Functions

A core FP principle is immutability — once created, data should not change. This avoids side effects and makes code more predictable.

While Java allows mutable state, you can follow FP practices by:

• Using immutable objects (eg, String , LocalDateTime , or custom classes with final fields)
• Avoiding state mutation in functions
• Writing pure functions — same input always gives same output, with no side effects

Example of a pure function:

 public static int square(int x) {
    return x * x; // No side effects, no state change
}

Avoid:

 private static int counter = 0;
public static int impureAdd(int x) {
    return x ( counter); // Depends on external state — not pure
}

Tip: Use Collections.unmodifiableList() or libraries like Google Guava or records (Java 14 ) to create immutable data structures.

3. Higher-Order Functions with Streams

Java's Stream API (introduced in Java 8) is heavily inspired by functional programming. It allows you to process data in a declarative way — focusing on what to do, not how .

Common FP-style operations:

• map – transform elements
• filter – select elements based on condition
• reduce – combine elements into one result
• forEach – perform action on each (side effect)

Example:

 List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Functional style: get sum of squares of even numbers
int result = numbers.stream()
    .filter(n -> n % 2 == 0)
    .map(n -> n * n)
    .reduce(0, Integer::sum);

System.out.println(result); // 20 (4 16)

This is more readable and less error-prone than loops and temporary variables.

4. Function Composition

In FP, functions can be composed to build more complex behavior. Java supports this via methods like andThen and compose on Function .

Example:

 Function<Integer, Integer> square = x -> x * x;
Function<Integer, Integer> increment = x -> x 1;

// (x 1)^2
Function<Integer, Integer> incrementThenSquare = increment.andThen(square);
System.out.println(incrementThenSquare.apply(3)); // (3 1)^2 = 16

// x^2 1
Function<Integer, Integer> squareThenIncrement = square.andThen(increment);
System.out.println(squareThenIncrement.apply(3)); // 9 1 = 10

This allows building pipelines of transformations in a clean, reusable way.

5. Avoiding Side Effects and Embracing Expressions

Functional programming favors expressions over statements. In Java, lambdas and streams help shift towards expression-based coding.

Prefer:

 Optional<String> result = list.stream()
    .filter(s -> s.startsWith("A"))
    .findFirst();

Over:

 String result = null;
for (String s: list) {
    if (s.startsWith("A")) {
        result = s;
        break;
    }
}

The stream version is more concise and less prone to bugs.

Also, avoid mutating external state inside lambdas — keep them state-free when possible.

Summary

Even though Java is object-oriented at its core, you can apply functional programming concepts effectively:

• Use lambda expressions and functional interfaces to pass behavior
• Leverage the Stream API for declarative data processing
• Favor immutability and pure functions to reduce bugs
• Compose functions using andThen / compose
• Minimize side effects and shared state

These practices lead to code that's easier to reason about, test, and parallelize (eg, parallelStream() ).

Basically, you don't need Haskell to do functional programming — Java gives you enough tools to start thinking and coding functionally.

The above is the detailed content of Functional Programming Concepts in Java. For more information, please follow other related articles on the PHP Chinese website!