Kotlin中静态函数多次调用时如何复用可变变量？

首先明确：Kotlin 的函数参数默认都是 val（不可变），语言不允许用 var 修饰函数参数，这是设计上的规则——参数本质是函数内部的局部只读变量，只能读取或调用其可变方法（比如修改数组元素），但不能重新赋值。

针对你想在多个静态函数间复用可变变量（如索引）、减少对象创建以降低GC的需求，以下是几种可行方案：

1. 顶层可变属性 #

直接定义顶层的可变属性，所有顶层函数（对应Java的静态函数）都可以直接读写它：

// 顶层属性，全局可访问
var reuseIndex = 0

fun processFirstArray(arr: IntArray): IntArray {
    reuseIndex = 0 // 重置索引
    while (reuseIndex < arr.size) {
        arr[reuseIndex] *= 2
        reuseIndex++
    }
    return arr
}

fun processSecondArray(arr: IntArray): IntArray {
    reuseIndex = 0
    while (reuseIndex < arr.size) {
        arr[reuseIndex] += 5
        reuseIndex++
    }
    return arr
}

注意：如果是多线程环境，需要额外处理线程安全（比如用 AtomicInteger 替代普通 Int），避免并发读写冲突。

2. 伴生对象属性 #

如果不想用全局顶层属性，可以把可变变量放在类的伴生对象中，仅让该类的伴生函数（即静态函数）访问：

class ArrayProcessor {
    companion object {
        var reuseIndex = 0

        fun processFirstArray(arr: IntArray): IntArray {
            reuseIndex = 0
            while (reuseIndex < arr.size) {
                arr[reuseIndex] *= 2
                reuseIndex++
            }
            return arr
        }

        fun processSecondArray(arr: IntArray): IntArray {
            reuseIndex = 0
            while (reuseIndex < arr.size) {
                arr[reuseIndex] += 5
                reuseIndex++
            }
            return arr
        }
    }
}

这种方式比顶层属性更有封装性，变量的作用域被限制在伴生对象内。

3. 自定义包装类传递 #

如果不想用静态属性（担心全局状态带来的问题），可以自定义一个简单的包装类，将可变变量放在其中，然后把包装类实例作为参数传递给各个函数：

// 包装类，持有可变值
data class IntHolder(var value: Int)

fun processFirstArray(arr: IntArray, holder: IntHolder): IntArray {
    holder.value = 0
    while (holder.value < arr.size) {
        arr[holder.value] *= 2
        holder.value++
    }
    return arr
}

fun processSecondArray(arr: IntArray, holder: IntHolder): IntArray {
    holder.value = 0
    while (holder.value < arr.size) {
        arr[holder.value] += 5
        holder.value++
    }
    return arr
}

// 使用方式
fun main() {
    val holder = IntHolder(0) // 只创建一次
    val arr1 = intArrayOf(1,2,3)
    val arr2 = intArrayOf(4,5,6)
    processFirstArray(arr1, holder)
    processSecondArray(arr2, holder)
}

这种方式没有全局状态，且只需创建一次IntHolder实例，多次复用，避免频繁创建对象带来的GC开销。

关于你提到的数组/列表参数：函数参数的数组是val，意味着你不能把参数重新赋值为新的数组（比如arr = intArrayOf(1,2)是不允许的），但数组本身是可变容器，所以修改其元素（arr[index] = 10）是完全合法的——这和参数的不可变性不冲突，你只是修改了对象内部的数据，而非参数变量的引用。

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