如何将复杂Java Lambda转换为Kotlin？含接口优化与惯用设计问询

原Java代码 #

public class Test {
    public static void main(String[] args) {
        validate("some text", extractor -> s -> check(s, extractor));
    }

    private static void validate(String s, Function<Extractor, Validator> factory) {
        final Extractor extractor = all -> all; // 此处可替换为更有意义的提取逻辑
        factory.apply(extractor).validate(s);
    }

    private static boolean check(String s, Extractor extractor) {
        return s.equals(extractor.extract(s));
    }

    interface Extractor {
        String extract(String all);
    }

    interface Validator {
        boolean validate(String s);
    }
}

当前Kotlin实现（保留原有接口） #

object Test {
    fun main(args: Array<String>) {
        validate("test", object : Function<Extractor, Validator> {
            override fun apply(extractor: Extractor): Validator {
                return object : Validator {
                    override fun validate(s: String): Boolean {
                        return check(s, extractor)
                    }
                }
            }
        })
    }

    private fun validate(s: String, factory: Function<Extractor, Validator>) {
        val extractor : Extractor = object : Extractor {  // 此处可替换为更有意义的提取逻辑
            override fun extract(all: String): String {
                return all
            }
        }
        factory.apply(extractor).validate(s)
    }

    private fun check(s: String, extractor: Extractor): Boolean {
        return s == extractor.extract(s)
    }

    internal interface Extractor {
        fun extract(all: String): String
    }

    internal interface Validator {
        fun validate(s: String): Boolean
    }
}

问题 #

1. 在保留原有接口的情况下，是否有更简洁高效的validate调用方式？
2. 业务逻辑需要可配置的验证（Validator），其复杂校验方法依赖可配置的提取逻辑（Extractor），请问更符合Kotlin惯用的设计方案是什么？

解答 #

一、保留原有接口的简洁写法 #

Kotlin支持SAM转换（单抽象方法转换），只要接口仅包含一个抽象方法，就可以直接用Lambda表达式替代匿名内部类，无需手动编写object : XXX的冗余结构。

简化main中的validate调用

fun main(args: Array<String>) {
    validate("test") { extractor ->
        Validator { s -> check(s, extractor) }
    }
}

甚至可以进一步压缩为更紧凑的版本：

fun main(args: Array<String>) {
    validate("test") { extractor -> { s -> check(s, extractor) } as Validator }
}

简化Extractor实例创建

private fun validate(s: String, factory: Function<Extractor, Validator>) {
    val extractor = Extractor { all -> all } // 用SAM转换直接生成实例
    factory.apply(extractor).validate(s)
}

二、Kotlin惯用设计方案 #

在Kotlin中，更推荐用函数类型替代单抽象方法接口，彻底摆脱接口定义，让代码更简洁、更贴合函数式编程风格：

方案1：完全用函数类型替代接口

object Test {
    fun main(args: Array<String>) {
        // 直接传递嵌套Lambda，无需额外接口定义
        validate("test") { extractor -> { s -> check(s, extractor) } }
    }

    // 用函数类型替代原有的Function<Extractor, Validator>
    private fun validate(s: String, factory: (String) -> (String) -> Boolean) {
        val extractor: (String) -> String = { all -> all } // 提取逻辑直接用函数表示
        factory(extractor)(s)
    }

    private fun check(s: String, extractor: (String) -> String): Boolean {
        return s == extractor(s)
    }
}

方案2：用类型别名增强语义可读性

如果需要明确区分提取器和验证器的职责，避免函数类型过于抽象，可以用类型别名来增强代码可读性：

object Test {
    // 用类型别名明确语义，兼顾简洁性和可读性
    typealias Extractor = (String) -> String
    typealias Validator = (String) -> Boolean

    fun main(args: Array<String>) {
        validate("test") { extractor -> Validator { s -> check(s, extractor) } }
    }

    private fun validate(s: String, factory: (Extractor) -> Validator) {
        val extractor: Extractor = { all -> all }
        factory(extractor)(s)
    }

    private fun check(s: String, extractor: Extractor): Boolean {
        return s == extractor(s)
    }
}

方案3：复杂场景下的类封装

如果提取或验证逻辑需要维护状态，可以封装为类，结合高阶函数使用：

class StatefulExtractor(private val prefix: String) : (String) -> String {
    override fun invoke(all: String): String {
        return prefix + all
    }
}

fun main(args: Array<String>) {
    val extractor = StatefulExtractor("prefix_")
    validate("test") { ext -> { s -> s == ext(s) } }
}

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