在Kotlin中，如何在迭代时修改列表的内容

问题描述

我有一个清单：

val someList = listOf(1, 20, 10, 55, 30, 22, 11, 0, 99)

我想在修改时迭代它一些价值观。我知道我可以使用 map 来完成它，但这会生成列表的副本。

And I want to iterate it while modifying some of the values. I know I can do it with map but that makes a copy of the list.

val copyOfList = someList.map { if (it <= 20) it + 20 else it }

如何在没有副本的情况下执行此操作？

How do I do this without a copy?

注意： 这个问题是由作者故意编写和回答的（），以便在SO中提供常见的Kotlin主题的惯用答案。还要澄清为Kotlin的alphas写的一些非常古老的答案，这些答案对于当前的Kotlin来说是不准确的。

Note: this question is intentionally written and answered by the author (Self-Answered Questions), so that the idiomatic answers to commonly asked Kotlin topics are present in SO. Also to clarify some really old answers written for alphas of Kotlin that are not accurate for current-day Kotlin.

推荐答案

首先，并非所有复制列表都不好。有时副本可以利用CPU缓存并且非常快，这取决于列表，大小和其他因素。

First, not all copying of a list is bad. Sometimes a copy can take advantage of CPU cache and be extremely fast, it depends on the list, size, and other factors.

其次，用于修改列表in-放置你需要使用一种可变的列表。在您的示例中，您使用 listOf 返回 List< T> 界面，这是只读的。你需要直接引用一个可变列表的类（即 ArrayList ），或者是惯用的Kotlin来使用辅助函数 arrayListOf 或 linkedListOf 创建一个 MutableList< T> 引用。一旦你有了，你可以使用 listIterator（）迭代列表，其中有一个变异方法 set（）。

Second, for modifying a list "in-place" you need to use a type of list that is mutable. In your sample you use listOf which returns the List<T> interface, and that is read-only. You need to directly reference the class of a mutable list (i.e. ArrayList), or it is idiomatic Kotlin to use the helper functions arrayListOf or linkedListOf to create a MutableList<T> reference. Once you have that, you can iterate the list using the listIterator() which has a mutation method set().

// create a mutable list
val someList = arrayListOf(1, 20, 10, 55, 30, 22, 11, 0, 99)

// iterate it using a mutable iterator and modify values
val iterate = someList.listIterator()
while (iterate.hasNext()) {
    val oldValue = iterate.next()
    if (oldValue <= 20) iterate.set(oldValue + 20)
}

这将在迭代发生时更改列表中的值，并且对所有列表类型都有效。为了使这更容易，创建有用的扩展函数，您可以重复使用（见下文）。

This will change the values in the list as iteration occurs and is efficient for all list types. To make this easier, create helpful extension functions that you can re-use (see below).

您可以为Kotlin编写扩展函数，为任何 MutableList 实现执行可变迭代迭代。这些内联函数的执行速度与迭代器的任何自定义使用速度一样快，内联函数也是如此。完美适用于Android或任何地方。

You can write extension functions for Kotlin that do an in place mutable iteration for any MutableList implementation. These inline functions will perform as fast as any custom use of the iterator and is inlined for performance. Perfect for Android or anywhere.

这是一个 mapInPlace 扩展功能（它保留了这些类型的典型命名函数，如 map 和 mapTo ）：

Here is a mapInPlace extension function (which keeps the naming typical for these type of functions such as map and mapTo):

inline fun <T> MutableList<T>.mapInPlace(mutator: (T)->T) {
    val iterate = this.listIterator()
    while (iterate.hasNext()) {
        val oldValue = iterate.next()
        val newValue = mutator(oldValue)
        if (newValue !== oldValue) {
            iterate.set(newValue)
        }
    }
}

示例调用此扩展功能的任何变体：

Example calling any variation of this extension function:

val someList = arrayListOf(1, 20, 10, 55, 30, 22, 11, 0, 99)
someList.mapInPlace { if (it <= 20) it + 20 else it }

这不是对所有 Collection< T> 进行推广，因为大多数迭代器只有 remove（）方法，而不是 set（）。

This is not generalized for all Collection<T>, because most iterators only have a remove() method, not set().

你可以处理具有类似方法的通用数组：

You can handle generic arrays with a similar method:

inline fun <T> Array<T>.mapInPlace(mutator: (T)->T) {
    this.forEachIndexed { idx, value ->
        mutator(value).let { newValue ->
            if (newValue !== value) this[idx] = mutator(value)
        }
    }
}

对于每个原始数组，使用以下变体：

And for each of the primitive arrays, use a variation of:

inline fun BooleanArray.mapInPlace(mutator: (Boolean)->Boolean) {
    this.forEachIndexed { idx, value ->
        mutator(value).let { newValue ->
            if (newValue !== value) this[idx] = mutator(value)
        }
    }
}

关于仅使用参考等式的优化

上面的扩展函数通过不设置值来优化一点它没有更改为其他实例，检查使用 === 或！== 是。不值得检查 equals（）或 hashCode（）因为调用它们的成本未知，实际上是参照平等捕获任何改变价值的意图。

About the Optimization using only Reference Equality

The extension functions above optimize a little by not setting the value if it has not changed to a different instance, checking that using === or !== is Referential Equality. It isn't worth checking equals() or hashCode() because calling those has an unknown cost, and really the referential equality catches any intent to change the value.

以下是显示功能正常的单元测试用例，以及一个小的比较到stdlib函数 map（）进行复制：

Here are unit test cases showing the functions working, and also a small comparison to the stdlib function map() that makes a copy:

class MapInPlaceTests {
    @Test fun testMutationIterationOfList() {
        val unhappy = setOf("Sad", "Angry")
        val startingList = listOf("Happy", "Sad", "Angry", "Love")
        val expectedResults = listOf("Happy", "Love", "Love", "Love")

        // modify existing list with custom extension function
        val mutableList = startingList.toArrayList()
        mutableList.mapInPlace { if (it in unhappy) "Love" else it }
        assertEquals(expectedResults, mutableList)
    }

    @Test fun testMutationIterationOfArrays() {
        val otherArray = arrayOf(true, false, false, false, true)
        otherArray.mapInPlace { true }
        assertEquals(arrayOf(true, true, true, true, true).toList(), otherArray.toList())
    }

    @Test fun testMutationIterationOfPrimitiveArrays() {
        val primArray = booleanArrayOf(true, false, false, false, true)
        primArray.mapInPlace { true }
        assertEquals(booleanArrayOf(true, true, true, true, true).toList(), primArray.toList())
    }

    @Test fun testMutationIterationOfListWithPrimitives() {
        val otherList = arrayListOf(true, false, false, false, true)
        otherList.mapInPlace { true }
        assertEquals(listOf(true, true, true, true, true), otherList)
    }
}

这篇关于在Kotlin中，如何在迭代时修改列表的内容的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！