在Android应用程序的数据类模型属性中折叠Kotlin

我不确定标题是否足够清晰，因此我将在这里解释： 我有四种型号：

这个模型是我用来解析文件中的JSON的模型

@JsonClass(generateAdapter = true)
data class Account(
    val account: String,
    val balance: String,
    val transactions: List<Transaction>
)

对于UI层，我有一些等效的模型：

data class AccountEntity(
    val account: String,
    val balance: String,
    val transactions: List<TransactionEntity>
)

我想做的一件棘手的事情是，一个

账户

有一个

余额

，我需要在每个

交易数据

中显示

之前的余额

和

之后的余额

，它们分别是进行此交易之前的账户余额，以及交易完成后的账户余额

对我来说，这不仅要理解而且要实现都有点棘手。 我曾想过在每个事务中实现某种

折叠

操作，但我不确定如何仅在

balanceBefore

和

balanceAfter

属性中应用它

还有别的想法吗？

---

提前多谢

嗯，这是某种

减少/折叠

功能，它还允许您映射

您的
事务
对象

此函数的作用是跟踪累加器中的当前余额，并转换每个
事务
对象：

inline fun <R> List<Transaction>.map(
    initial: Int,
    transform: (transaction: Transaction, beforeBalance: Int, afterBalance: Int) -> R
): List<R> {
    var accumulator = initial
    val destination = ArrayList<R>()

    for (transaction in this) {
        val after = accumulator - transaction.amount
        destination.add(transform(transaction, accumulator, after))
        accumulator = after
    }
    return destination
}

为了更通用和更实用，您可以将此行
累加器-transaction.amount
移动到函数参数中作为折叠输入，并调用函数foldMap或任何减少当前事务并将其映射的函数。
，这是一种
reduce/fold
功能，它还允许您
映射
您的
事务
对象

此函数的作用是跟踪累加器中的当前余额，并转换每个
事务
对象：

inline fun <R> List<Transaction>.map(
    initial: Int,
    transform: (transaction: Transaction, beforeBalance: Int, afterBalance: Int) -> R
): List<R> {
    var accumulator = initial
    val destination = ArrayList<R>()

    for (transaction in this) {
        val after = accumulator - transaction.amount
        destination.add(transform(transaction, accumulator, after))
        accumulator = after
    }
    return destination
}

为了更通用和更实用，您可以将此行
累加器-交易.金额
作为折叠输入移动到函数参数，并调用函数foldMap或任何减少当前交易并将其映射的函数。
您在哪里进行这些交易？使用房间？不，我没有使用DB或任何东西。有了
Transaction
我指的是银行交易，它是一个银行应用程序。你在哪里做的这些交易？使用房间？不，我没有使用DB或任何东西。使用
Transaction
我指的是银行交易，这是一个银行应用程序。非常感谢，伙计，这真是我一直在寻找的答案！非常感谢，这真的是我一直在寻找的答案！
inline fun <R> List<Transaction>.map(
    initial: Int,
    transform: (transaction: Transaction, beforeBalance: Int, afterBalance: Int) -> R
): List<R> {
    var accumulator = initial
    val destination = ArrayList<R>()

    for (transaction in this) {
        val after = accumulator - transaction.amount
        destination.add(transform(transaction, accumulator, after))
        accumulator = after
    }
    return destination
}

account.transactions.map(account.balance, {t, b, a-> TransactionEntity(...)})