Using Java 8 Functional Interfaces to Replace Traditional if…else Branches

In Java development, the ubiquitous if...else... pattern often clutters code and reduces readability. By leveraging Java 8’s functional interfaces—annotated with @FunctionalInterface —developers can replace these constructs with lambda‑based solutions.

Function Functional Interface

The @FunctionalInterface annotation marks an interface that contains exactly one abstract method, making it eligible for lambda expressions. Common functional interfaces include Supplier (no arguments, returns a value), Consumer (accepts a value, returns nothing), Runnable (no arguments, no return), and Function (accepts a value and returns a result).

Function can be viewed as a transformation function.

Supplier (Provider) Function

A Supplier takes no parameters and returns a result.

Consumer Function

A Consumer accepts a single argument and returns nothing.

Runnable (No‑arg, No‑return) Function

Runnable represents an operation with neither parameters nor a return value.

Both Supplier , Consumer and Runnable can be seen as special forms of Function .

Handling Exception‑Throwing if Statements

1. Define a functional interface

/**
 * Throw exception interface
 */
@FunctionalInterface
public interface ThrowExceptionFunction {
    /**
     * Throw an exception with the given message
     * @param message exception message
     */
    void throwMessage(String message);
}

2. Implement a helper method

/**
 * Returns a ThrowExceptionFunction that throws when the boolean is true
 */
public static ThrowExceptionFunction isTrue(boolean b) {
    return (errorMessage) -> {
        if (b) {
            throw new RuntimeException(errorMessage);
        }
    };
}

3. Usage

Invoke the returned functional interface and call throwMessage with an error string; if the parameter is false, execution proceeds normally.

Handling if Branch Operations

1. Define a functional interface

/**
 * Branch handling interface
 */
@FunctionalInterface
public interface BranchHandle {
    /**
     * Execute trueHandle when b is true, otherwise falseHandle
     */
    void trueOrFalseHandle(Runnable trueHandle, Runnable falseHandle);
}

2. Implement a helper method

/**
 * Returns a BranchHandle that runs the appropriate Runnable based on b
 */
public static BranchHandle isTrueOrFalse(boolean b) {
    return (trueHandle, falseHandle) -> {
        if (b) {
            trueHandle.run();
        } else {
            falseHandle.run();
        }
    };
}

3. Usage

When the parameter is true, trueHandle runs; otherwise falseHandle runs.

Present‑or‑Else Handling (Value‑Present vs. Empty)

1. Define a functional interface

/**
 * Handles present and empty values
 */
public interface PresentOrElseHandler
{
    /**
     * Executes action when value is present, otherwise runs emptyAction
     */
    void presentOrElseHandle(Consumer
action, Runnable emptyAction);
}

2. Implement a helper method

/**
 * Returns a handler that checks if a string is blank
 */
public static PresentOrElseHandler
isBlankOrNoBlank(String str) {
    return (consumer, runnable) -> {
        if (str == null || str.length() == 0) {
            runnable.run();
        } else {
            consumer.accept(str);
        }
    };
}

3. Usage

Pass a Consumer to process a non‑null value and a Runnable for the empty case.

Conclusion

Java 8 functional interfaces are a powerful feature; using them effectively can greatly simplify code by removing repetitive if...else... blocks and making exception handling and branching more declarative.

Source: juejin.cn/post/7011435192803917831