How to Replace Cluttered if…else… with Java 8 Functional Interfaces

Function Functional Interface

In development, if...else... statements for throwing exceptions or handling branches clutter code; Java 8's Function functional interface can replace them.

Using Annotations

Mark an interface with @FunctionalInterface; it must contain a single abstract method, making it a functional interface. Common functional interfaces include Supplier (no arguments, returns a value), Consumer (accepts an argument, returns nothing), Runnable (no arguments, no return), and Function (accepts an argument and returns a value).

Function can be seen as a conversion function.

Supplier (Supply‑type Function)

Represents a function that takes no parameters and returns data.

Consumer (Consume‑type Function)

Opposite of Supplier; accepts a parameter and returns nothing.

Runnable (No‑arg, No‑return Function)

Has neither parameters nor a return value.

Function (Argument‑to‑Result Function)

Accepts one argument and returns a value; it can be considered a special form of the other functional interfaces.

Practical Tips

Handling Exception‑Throwing if

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

Utility method that returns a ThrowExceptionFunction which throws an exception when the boolean parameter is true:

public static ThrowExceptionFunction isTure(boolean b) {
    return (errorMessage) -> {
        if (b) {
            throw new RuntimeException(errorMessage);
        }
    };
}

Branch Handling

@FunctionalInterface
public interface BranchHandle {
    /**
     * Execute different actions based on a boolean value
     */
    void trueOrFalseHandle(Runnable trueHandle, Runnable falseHandle);
}

public static BranchHandle isTureOrFalse(boolean b) {
    return (trueHandle, falseHandle) -> {
        if (b) {
            trueHandle.run();
        } else {
            falseHandle.run();
        }
    };
}

Present‑or‑Else Handling

@FunctionalInterface
public interface PresentOrElseHandler<T extends Object> {
    /**
     * Execute <code>action</code> when value is present, otherwise run <code>emptyAction</code>
     */
    void presentOrElseHandle(Consumer<? super T> action, Runnable emptyAction);
}

public static PresentOrElseHandler<?> isBlankOrNoBlank(String str) {
    return (consumer, runnable) -> {
        if (str == null || str.length() == 0) {
            runnable.run();
        } else {
            consumer.accept(str);
        }
    };
}

Usage examples show how to pass lambda expressions to these utilities, simplifying exception throwing and branch logic without explicit if…else blocks.

Conclusion

Function

functional interfaces are a crucial feature of Java 8; using them effectively can greatly simplify code by removing repetitive conditional statements.