Java 8 Functional Interfaces: Simplifying Conditional Logic with Function, Supplier, Consumer, and Runnable

The article begins with a brief notice about a free programmer book resource that can be obtained from the backend "Learning Materials" menu.

It then points out that excessive use of if...else... statements makes code hard to read, and suggests using Java 8's functional interfaces to eliminate such boilerplate.

The @FunctionalInterface annotation is introduced, and the four core functional interfaces— 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)—are described.

A custom functional interface for throwing exceptions is defined, along with a utility method that returns an implementation based on a boolean flag.

/**
 * 抛异常接口
 */
@FunctionalInterface
public interface ThrowExceptionFunction {
    void throwMessage(String message);
}

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

Next, a BranchHandle functional interface is introduced to handle true/false branches, and a method returning a lambda implementation is provided.

/**
 * 分支处理接口
 */
@FunctionalInterface
public interface BranchHandle {
    void trueOrFalseHandle(Runnable trueHandle, Runnable falseHandle);
}

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

The article also presents a PresentOrElseHandler interface for handling optional values, with a method that decides between a Consumer and a Runnable based on whether a string is empty.

public interface PresentOrElseHandler
{
    void presentOrElseHandle(Consumer
action, Runnable emptyAction);
}

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

Finally, the article concludes that Java 8 functional interfaces are a powerful feature that, when used effectively, can greatly simplify code and improve maintainability.