Great question—this is such a common pain point when working with Builders, and it’s totally possible to achieve that clean, single-line style without dumping condition logic into your Builder or writing messy multi-line if checks. Let’s break down the best approaches:

1. Add a Generic applyIf Method to Your Builder #

This is my go-to solution because it keeps your Builder focused on its core responsibility (constructing objects) while letting you handle conditionals externally in a fluent way.

First, add this simple method to your Builder class:

public Builder applyIf(boolean condition, Consumer<Builder> action) {
    if (condition) {
        action.accept(this);
    }
    return this;
}

Now you can chain your optional parameter logic directly in the Builder call, no multi-line code needed:

MyObject obj = Builder.name("name")
                      .id("id")
                      .applyIf(complexCondition, b -> b.age(age))
                      .build();

The Builder never knows about your complexCondition—it just executes the provided action if the condition is true. This stays true to the single responsibility principle and keeps your client code clean.

2. Use Optional for Conditional Application #

If you prefer not to modify the Builder class (maybe it’s generated code), you can leverage Optional to wrap your optional parameter and apply it conditionally:

Builder builder = Builder.name("name").id("id");
Optional.of(age)
        .filter(__ -> complexCondition) // Use a dummy variable if you don't need the value here
        .ifPresent(builder::age);
MyObject obj = builder.build();

If you want to keep it closer to a single line (though slightly less readable), you can chain it like this:

MyObject obj = Optional.of(Builder.name("name").id("id"))
                       .map(b -> {
                           if (complexCondition) b.age(age);
                           return b;
                       })
                       .get()
                       .build();

3. Avoid These Less Ideal Approaches #

• Passing conditions to Builder methods: Like your first example age(age, complexCondition)—this violates single responsibility because the Builder shouldn’t care about when to set a parameter.
• Multi-line if checks: Your second approach works, but it breaks the fluent chain and adds unnecessary boilerplate for every optional parameter.

Whichever method you choose, the key is keeping conditional logic outside the Builder while maintaining that clean, chained syntax you’re after.

内容的提问来源于stack exchange，提问作者Andrii Plotnikov