Java 中可以做到函数嵌套吗

我知道可以通过 Runnable 来让 lambda 前置并在后面调用，而且最终实际上是通过包装成私有函数运行，不会有额外开销。但是有没有办法让子函数体后置，业务代码在前？

函数式编程貌似可以做到。Java 中有没有办法呢。

至于为什么不用 kt ，嗯，公司业务积重难返了。

function parentFunction() {
    // 业务代码部分
    const data = [1, 2, 3, 4, 5];
    
    const doubled = doubleData(data);
    console.log('Doubled Data:', doubled);
    
    const filtered = filterData(doubled, isEven);
    console.log('Filtered Data (Even):', filtered);
    
    // 子函数定义部分
    function doubleData(arr) {
        return arr.map(function(num) {
            return multiply(num, 2);
        });
    }

    function multiply(a, b) {
        return a * b;
    }

    function filterData(arr, predicate) {
        const result = [];
        for (let i = 0; i < arr.length; i++) {
            if (predicate(arr[i])) {
                result.push(arr[i]);
            }
        }
        return result;
    }

    function isEven(num) {
        return num % 2 === 0;
    }
}

fun parentFunction() {
    // 业务代码部分
    val data = listOf(1, 2, 3, 4, 5)
    
    val doubled = doubleData(data)
    println("Doubled Data: $doubled")
    
    val filtered = filterData(doubled, ::isEven)
    println("Filtered Data (Even): $filtered")

    // 子函数定义部分
    fun doubleData(arr: List<Int>): List<Int> {
        return arr.map { multiply(it, 2) }
    }

    fun multiply(a: Int, b: Int): Int {
        return a * b
    }

    fun filterData(arr: List<Int>, predicate: (Int) -> Boolean): List<Int> {
        return arr.filter(predicate)
    }

    fun isEven(num: Int): Boolean {
        return num % 2 == 0
    }
}