Kotlin中用apply+forEach配置Label数组是否为建造者模式？求优化写法

Great question—let’s clarify this first. The classic Builder Pattern is about separating the construction of a complex object from its representation, usually via a dedicated builder class that lets you chain configuration steps before finalizing the object.

Your approach using apply + forEach is more of a post-creation configuration of an existing array. You’re first creating the array of Label instances, then iterating to set their properties. While it uses "builder-style" syntax (thanks to Kotlin’s scope functions), it’s not a strict implementation of the Builder Pattern. The key difference is that the Builder Pattern typically builds the object from scratch through incremental steps, rather than modifying an already-created collection.

Kotlin’s standard library has fantastic tools to make this cleaner and more intuitive. Here are my top recommendations:

1. Use buildList (Most Recommended) #

Introduced in Kotlin 1.3, buildList is designed explicitly for constructing and configuring lists in a single, readable block. It replaces the need to create an empty collection first and then modify it:

val labels = buildList<Label> {
    // Add and configure each Label directly in the block
    add(Label().apply {
        text = "Welcome Label"
        textColor = Color.BLUE
        fontSize = 18
    })
    add(Label().apply {
        text = "Error Label"
        textColor = Color.RED
        fontSize = 14
        isBold = true
    })
    // If your Label has a parameterized constructor, you can shorten it even more
    add(Label("Info Label").apply {
        textColor = Color.GRAY
    })
}

This approach is concise, readable, and clearly signals your intent: "I’m building a list of Labels with specific configurations."

2. Reuse Base Configurations with copy (For Data Classes) #

If Label is a data class (or has a copy function), you can define a base label with default settings and copy it with overrides. This cuts down on repetition:

// Define a base Label with common settings
val baseLabel = Label(text = "", textColor = Color.BLACK, fontSize = 16)

val labels = listOf(
    baseLabel.copy(text = "Home"),
    baseLabel.copy(text = "Settings", fontSize = 14),
    baseLabel.copy(text = "Logout", textColor = Color.RED)
)

3. Custom Builder Class (For Complex Logic) #

If you need more control over the construction process (e.g., validation, conditional additions, or reusable configuration rules), a custom builder class is the way to go—this is closer to the classic Builder Pattern:

class LabelListBuilder {
    private val labels = mutableListOf<Label>()

    // Add a Label with a configuration lambda
    fun label(init: Label.() -> Unit) = apply {
        labels.add(Label().apply(init))
    }

    // Add a pre-configured Label
    fun add(label: Label) = apply {
        labels.add(label)
    }

    // Finalize and return the immutable list
    fun build(): List<Label> = labels.toList()
}

// Usage
val labels = LabelListBuilder()
    .label {
        text = "First Item"
        fontSize = 18
    }
    .label {
        text = "Second Item"
        isItalic = true
    }
    .add(Label("Pre-made Label"))
    .build()

If your use case is simple (just configuring a small array of Labels), your existing apply + forEach approach works—it’s functional and uses Kotlin’s syntax effectively. However, buildList is more idiomatic because it eliminates the extra step of creating an empty array first and makes your intent clearer at a glance.

For larger or more complex collections, switching to buildList or a custom builder will make your code easier to maintain and extend.

内容的提问来源于stack exchange，提问作者J.E.Tkaczyk